Class AsyncSuperEnumerable
Provides a set of static methods for querying objects that implement IAsyncEnumerable<T>.
Inherited Members
Namespace: SuperLinq.Async
Assembly: SuperLinq.Async.dll
Syntax
public static class AsyncSuperEnumerableMethods
| Name | Description |
|---|---|
| AggregateBy<TSource, TKey, TAccumulate>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TAccumulate>, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns an aggregate value for each key. An additional argument specifies a comparer to use for testing equivalence of keys. |
| AggregateBy<TSource, TKey, TAccumulate>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns an aggregate value for each key. An additional argument specifies a comparer to use for testing equivalence of keys. |
| AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, CancellationToken, ValueTask<TSource>>, CancellationToken) | Applies a right-associative accumulator function over a sequence. This operator is the right-associative version of the Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, ValueTask<TSource>>, CancellationToken) | Applies a right-associative accumulator function over a sequence. This operator is the right-associative version of the Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>, CancellationToken) | Applies a right-associative accumulator function over a sequence. This operator is the right-associative version of the Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<TAccumulate>>, CancellationToken) | 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 Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) LINQ operator. |
| AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<TAccumulate>>, CancellationToken) | 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 Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) LINQ operator. |
| AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, CancellationToken) | 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 Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) LINQ operator. |
| AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<TAccumulate>>, Func<TAccumulate, CancellationToken, ValueTask<TResult>>, CancellationToken) | 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 Aggregate<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>) LINQ operator. |
| AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<TAccumulate>>, Func<TAccumulate, ValueTask<TResult>>, CancellationToken) | 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 Aggregate<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>) LINQ operator. |
| AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>, CancellationToken) | 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 Aggregate<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>) LINQ operator. |
| Amb<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[]) | Propagates the async-enumerable sequence that reacts first. |
| Amb<TSource>(IEnumerable<IAsyncEnumerable<TSource>>) | Propagates the async-enumerable sequence that reacts first. |
| AssertCount<TSource>(IAsyncEnumerable<TSource>, int) | Asserts that a source sequence contains a given count of elements. |
| AtLeast<T>(IAsyncEnumerable<T>, int, CancellationToken) | Determines whether or not the number of elements in the sequence is greater than or equal to the given integer. |
| AtMost<T>(IAsyncEnumerable<T>, int, CancellationToken) | Determines whether or not the number of elements in the sequence is lesser than or equal to the given integer. |
| Batch<TSource>(IAsyncEnumerable<TSource>, int) | Split the elements of a sequence into chunks of size at most |
| BindByIndex<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<int>) | Selects elements by index from a sequence. |
| BindByIndex<TSource, TResult>(IAsyncEnumerable<TSource>, IAsyncEnumerable<int>, Func<TSource, int, TResult>, Func<int, TResult>) | Selects elements by index from a sequence and transforms them using the provided functions. |
| Buffer<TSource>(IAsyncEnumerable<TSource>, int) | Generates a sequence of non-overlapping adjacent buffers over the source sequence. |
| Buffer<TSource>(IAsyncEnumerable<TSource>, int, int) | Generates a sequence of buffers over the source sequence, with specified length and possible overlap. |
| Case<TValue, TResult>(Func<ValueTask<TValue>>, IDictionary<TValue, IAsyncEnumerable<TResult>>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Case<TValue, TResult>(Func<ValueTask<TValue>>, IDictionary<TValue, IAsyncEnumerable<TResult>>, IAsyncEnumerable<TResult>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Case<TValue, TResult>(Func<TValue>, IDictionary<TValue, IAsyncEnumerable<TResult>>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Case<TValue, TResult>(Func<TValue>, IDictionary<TValue, IAsyncEnumerable<TResult>>, IAsyncEnumerable<TResult>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Catch<TSource>(IAsyncEnumerable<IAsyncEnumerable<TSource>>) | Creates a sequence by concatenating source sequences until a source sequence completes successfully. |
| Catch<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>) | Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. |
| Catch<TSource>(params IAsyncEnumerable<TSource>[]) | Creates a sequence by concatenating source sequences until a source sequence completes successfully. |
| Catch<TSource>(IEnumerable<IAsyncEnumerable<TSource>>) | Creates a sequence by concatenating source sequences until a source sequence completes successfully. |
| Catch<TSource, TException>(IAsyncEnumerable<TSource>, Func<TException, IAsyncEnumerable<TSource>>) | Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. |
| Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, CancellationToken, ValueTask<(bool, TResult)>>) | Applies a function to each element of the source sequence and returns a new sequence of result elements for source elements where the function returns a couple (2-tuple) having a true as its first element and result as the second. |
| Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, ValueTask<(bool, TResult)>>) | Applies a function to each element of the source sequence and returns a new sequence of result elements for source elements where the function returns a couple (2-tuple) having a true as its first element and result as the second. |
| Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, (bool, TResult)>) | Applies a function to each element of the source sequence and returns a new sequence of result elements for source elements where the function returns a couple (2-tuple) having a true as its first element and result as the second. |
| CollectionEqual<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?, CancellationToken) | Determines whether two collections are equal by comparing the elements by using a specified IEqualityComparer<T>. |
| CollectionEqual<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, CancellationToken) | Determines whether two collections are equal by comparing the elements by using the default equality comparer for their type. |
| CompareCount<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, CancellationToken) | Compares two sequences and returns an integer that indicates whether the first sequence has fewer, the same or more elements than the second sequence. |
| ConcurrentMerge<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[]) | Concurrently iterates multiple IAsyncEnumerable<T> and returns elements from each stream in the order in which the iteration completes (which may or may not be in the same order as the sources are provided). |
| ConcurrentMerge<TSource>(IEnumerable<IAsyncEnumerable<TSource>>) | Concurrently iterates multiple IAsyncEnumerable<T> and returns elements from each stream in the order in which the iteration completes (which may or may not be in the same order as the sources are provided). |
| ConcurrentMerge<TSource>(IEnumerable<IAsyncEnumerable<TSource>>, int) | Concurrently iterates multiple IAsyncEnumerable<T> and returns elements from each stream in the order in which the iteration completes (which may or may not be in the same order as the sources are provided). |
| Consume<T>(IAsyncEnumerable<T>, CancellationToken) | Completely consumes the given sequence. This method uses immediate execution, and doesn't store any data during execution. |
| CopyTo<TSource>(IAsyncEnumerable<TSource>, IList<TSource>, int, CancellationToken) | Copies the contents of a sequence into a provided list. |
| CopyTo<TSource>(IAsyncEnumerable<TSource>, IList<TSource>, CancellationToken) | Copies the contents of a sequence into a provided list. |
| CountBetween<T>(IAsyncEnumerable<T>, int, int, CancellationToken) | Determines whether or not the number of elements in the sequence is between an inclusive range of minimum and maximum integers. |
| CountBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Applies a key-generating function to each element of a sequence and returns a sequence of unique keys and their number of occurrences in the original sequence. |
| CountBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns a sequence of unique keys and their number of occurrences in the original sequence. An additional argument specifies a comparer to use for testing equivalence of keys. |
| CountDown<TSource>(IAsyncEnumerable<TSource>, int) | Provides a countdown counter for a given count of elements at the tail of the sequence where zero always represents the last element, one represents the second-last element, two represents the third-last element and so on. |
| CountDown<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, int?, TResult>) | Provides a countdown counter for a given count of elements at the tail of the sequence where zero always represents the last element, one represents the second-last element, two represents the third-last element and so on. |
| Defer<TResult>(Func<IAsyncEnumerable<TResult>>) | Creates an enumerable sequence based on an enumerable factory function. |
| DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>) | Executes a partial sort of the top |
| DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection) | Executes a |
| DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?) | Executes a partial sort of the top |
| DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection) | Executes a |
| DensePartialSort<T>(IAsyncEnumerable<T>, int) | Executes a partial sort of the top |
| DensePartialSort<T>(IAsyncEnumerable<T>, int, OrderByDirection) | Executes a |
| DensePartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?) | Executes a partial sort of the top |
| DensePartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?, OrderByDirection) | Executes a |
| DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Ranks each item in the sequence in ascending order by a specified key using a default comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) | Ranks each item in the sequence in ascending order by a specified key using a caller-supplied comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRank<TSource>(IAsyncEnumerable<TSource>) | Ranks each item in the sequence in ascending order using a default comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRank<TSource>(IAsyncEnumerable<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>) | Ranks each item in the sequence in ascending order using a caller-supplied comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DistinctBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the default equality comparer for the projected type. |
| DistinctBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the specified comparer for the projected type. |
| DistinctUntilChanged<TSource>(IAsyncEnumerable<TSource>) | Returns consecutive distinct elements by using the default equality comparer to compare values. |
| DistinctUntilChanged<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?) | Returns consecutive distinct elements by using the specified equality comparer to compare values. |
| DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, IEqualityComparer<TKey>?) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DoWhile<TSource>(IAsyncEnumerable<TSource>, Func<bool>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. |
| DoWhile<TSource>(IAsyncEnumerable<TSource>, Func<ValueTask<bool>>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. |
| Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>) | Lazily invokes an action for each value in the sequence. |
| Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action) | Lazily invokes an action for each value in the sequence, and executes an action for successful termination. |
| Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action<Exception>) | Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. |
| Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action<Exception>, Action) | Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. |
| Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>) | Lazily invokes an action for each value in the sequence. |
| Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<Exception, ValueTask>) | Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. |
| Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<Exception, ValueTask>, Func<ValueTask>) | Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. |
| Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<ValueTask>) | Lazily invokes an action for each value in the sequence, and executes an action for successful termination. |
| Duplicates<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?) | Returns all duplicate elements of the given source. |
| ElementAtAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken) | Returns the element at a specified index in a sequence. |
| ElementAtOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken) | Returns the element at a specified index in a sequence or a default value if the index is out of range. |
| EndsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, IEqualityComparer<T>?, CancellationToken) | Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| EndsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, CancellationToken) | Determines whether the end of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| EndsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?, CancellationToken) | Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| EndsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, CancellationToken) | Determines whether the end of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| EquiZip<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>) | Joins the corresponding elements of second sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TThird>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>) | Joins the corresponding elements of third sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst, TSecond, TResult>) | Applies a specified function to the corresponding elements of second sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| EquiZip<TFirst, TSecond, TThird, TFourth>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>) | Joins the corresponding elements of fourth sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TThird, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>) | Applies a specified function to the corresponding elements of third sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>) | Applies a specified function to the corresponding elements of fourth sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| Evaluate<T>(IAsyncEnumerable<Func<Task<T>>>) | Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. |
| Evaluate<T>(IEnumerable<Func<Task<T>>>) | Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. |
| Exactly<T>(IAsyncEnumerable<T>, int, CancellationToken) | Determines whether or not the number of elements in the sequence is equals to the given integer. |
| ExceptBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector. |
| ExceptBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector. |
| FallbackIfEmpty<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>) | Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values. |
| FallbackIfEmpty<T>(IAsyncEnumerable<T>, IEnumerable<T>) | Returns the elements of a sequence, but if it is empty then returns an alternate sequence from an array of values. |
| FallbackIfEmpty<T>(IAsyncEnumerable<T>, params T[]) | Returns the elements of a sequence, but if it is empty then returns an alternate sequence from an array of values. |
| FillBackward<T>(IAsyncEnumerable<T>) | Returns a sequence with each null reference or value in the source replaced with the following non-null reference or value in that sequence. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, ValueTask<T>>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, ValueTask<T>>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillForward<T>(IAsyncEnumerable<T>) | Returns a sequence with each null reference or value in the source replaced with the previous non-null reference or value seen in that sequence. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>) | Returns a sequence with each missing element in the source replaced with the previous non-missing element seen in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, ValueTask<T>>) | Returns a sequence with each missing element in the source replaced with one based on the previous non-missing element seen in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with one based on the previous non-missing element seen in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>) | Returns a sequence with each missing element in the source replaced with the previous non-missing element seen in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, ValueTask<T>>) | Returns a sequence with each missing element in the source replaced with one based on the previous non-missing element seen in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with one based on the previous non-missing element seen in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| Finally<TSource>(IAsyncEnumerable<TSource>, Action) | Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. |
| FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, int, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the range of elements in the IAsyncEnumerable<T> that starts at the specified index to the last element and contains the specified number of elements. |
| FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the range of elements in the IAsyncEnumerable<T> that extends from the specified index to the last element. |
| FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the entire IAsyncEnumerable<T>. |
| FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, int, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the range of elements in the IAsyncEnumerable<T> that ends at the specified index to the last element and contains the specified number of elements. |
| FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the range of elements in the IAsyncEnumerable<T> that extends backwards from the specified index to the first element. |
| FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, CancellationToken) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the entire IAsyncEnumerable<T>. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 16 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 15 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 14 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 13 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 12 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 11 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 10 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 9 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 8 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 7 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 6 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 5 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 4 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, TResult>) | Returns the result of applying a function to a sequence of 3 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, TResult>) | Returns the result of applying a function to a sequence of 2 elements. |
| Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, TResult>) | Returns the result of applying a function to a sequence of 1 element. |
| ForEach<TSource>(IAsyncEnumerable<TSource>, Action<TSource, int>, CancellationToken) | Immediately executes the given action on each element in the source sequence. Each element's index is used in the logic of the action. |
| ForEach<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, CancellationToken) | Immediately executes the given action on each element in the source sequence. |
| ForEach<TSource>(IAsyncEnumerable<TSource>, Func<TSource, int, ValueTask>, CancellationToken) | Immediately executes the given action on each element in the source sequence. Each element's index is used in the logic of the action. |
| ForEach<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, CancellationToken) | Immediately executes the given action on each element in the source sequence. |
| From<T>(Func<Task<T>>) | Returns a single-element sequence containing the result of invoking the function. |
| From<T>(Func<Task<T>>, Func<Task<T>>) | Returns a sequence containing the result of invoking each parameter function in order. |
| From<T>(Func<Task<T>>, Func<Task<T>>, Func<Task<T>>) | Returns a sequence containing the result of invoking each parameter function in order. |
| From<T>(params Func<Task<T>>[]) | Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. |
| FullOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| Generate<TResult>(TResult, Func<TResult, CancellationToken, ValueTask<TResult>>) | Returns a sequence of values consecutively generated by a generator function. |
| Generate<TResult>(TResult, Func<TResult, ValueTask<TResult>>) | Returns a sequence of values consecutively generated by a generator function. |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, ValueTask<bool>>, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, ValueTask<bool>>, CancellationToken) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Calculate the cost of the shortest path from
state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState, CancellationToken) | Calculate the cost of the shortest path from
state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, Func<TState, ValueTask<bool>>, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, Func<TState, ValueTask<bool>>, CancellationToken) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Calculate the cost of the shortest path from
state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, TState, CancellationToken) | Calculate the cost of the shortest path from
state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>>, Func<TState, ValueTask<bool>>, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, ValueTask<bool>>, CancellationToken) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Find the shortest path from
state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState, CancellationToken) | Find the shortest path from
state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, Func<TState, ValueTask<bool>>, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, Func<TState, ValueTask<bool>>, CancellationToken) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Find the shortest path from
state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, TState, CancellationToken) | Find the shortest path from
state |
| GetShortestPaths<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, IEqualityComparer<TState>?, IComparer<TCost>?, CancellationToken) | Find the shortest path from state |
| GetShortestPaths<TState, TCost>(TState, Func<TState, TCost?, IAsyncEnumerable<(TState nextState, TCost cost)>>, CancellationToken) | Find the shortest path from state |
| GroupAdjacent<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Groups the adjacent elements of a sequence according to a specified key selector function. |
| GroupAdjacent<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer. |
| GroupAdjacent<TSource, TKey, TElement>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>) | Groups the adjacent elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function. |
| GroupAdjacent<TSource, TKey, TElement>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| GroupAdjacent<TSource, TKey, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| GroupAdjacent<TSource, TKey, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| HasDuplicates<T>(IAsyncEnumerable<T>) | Checks if sequence contains duplicates |
| HasDuplicates<T>(IAsyncEnumerable<T>, IEqualityComparer<T>?) | Checks if sequence contains duplicates, using the specified element equality comparer |
| HasDuplicates<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Checks if sequence contains duplicates, using the specified element equality comparer |
| HasDuplicates<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Checks if sequence contains duplicates, using the specified element equality comparer |
| Identity<T>(T) | Returns the identity function for a given type. |
| If<TResult>(Func<bool>, IAsyncEnumerable<TResult>) | Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. |
| If<TResult>(Func<bool>, IAsyncEnumerable<TResult>, IAsyncEnumerable<TResult>) | Returns an enumerable sequence based on the evaluation result of the given condition. |
| If<TResult>(Func<ValueTask<bool>>, IAsyncEnumerable<TResult>) | Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. |
| If<TResult>(Func<ValueTask<bool>>, IAsyncEnumerable<TResult>, IAsyncEnumerable<TResult>) | Returns an enumerable sequence based on the evaluation result of the given condition. |
| IndexBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Applies a key-generating function to each element of a sequence and returns a sequence that contains the elements of the original sequence as well its key and index inside the group of its key. |
| IndexBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns a sequence that contains the elements of the original sequence as well its key and index inside the group of its key. An additional parameter specifies a comparer to use for testing the equivalence of keys. |
| IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, int, CancellationToken) | Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the IAsyncEnumerable<T> that starts at the specified index to the last element and contains the specified number of elements. |
| IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, CancellationToken) | Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the IAsyncEnumerable<T> that extends from the specified index to the last element. |
| IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken) | Searches for the specified object and returns the zero-based index of the first occurrence within the entire IAsyncEnumerable<T>. |
| Index<TSource>(IAsyncEnumerable<TSource>) | Returns a sequence of tuples where the |
| Index<TSource>(IAsyncEnumerable<TSource>, int) | Returns a sequence of tuples where the |
| InnerHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerLoopJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerLoopJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| Insert<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, Index) | Inserts the elements of a sequence into another sequence at a specified index. |
| Insert<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, int) | Inserts the elements of a sequence into another sequence at a specified index. |
| Interleave<T>(IAsyncEnumerable<T>, params IAsyncEnumerable<T>[]) | Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed |
| Interleave<T>(IEnumerable<IAsyncEnumerable<T>>) | Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed |
| Lag<TSource>(IAsyncEnumerable<TSource>, int) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<TResult>>) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, int, CancellationToken) | Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the IAsyncEnumerable<T> that ends at the specified index to the last element and contains the specified number of elements. |
| LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, CancellationToken) | Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the IAsyncEnumerable<T> that extends backwards from the specified index to the first element. |
| LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken) | Searches for the specified object and returns the zero-based index of the last occurrence within the entire IAsyncEnumerable<T>. |
| Lead<TSource>(IAsyncEnumerable<TSource>, int) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<TResult>>) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| LeftOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterLoopJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| MaxByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the maximum value of a sequence. |
| MaxByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the maximum value of a sequence. |
| MaxItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the maximum value of a sequence. |
| MaxItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the maximum value of a sequence. |
| MaxItems<T>(IAsyncEnumerable<T>) | Returns all of the items that share the maximum value of a sequence. |
| MaxItems<T>(IAsyncEnumerable<T>, IComparer<T>?) | Returns all of the items that share the maximum value of a sequence. |
| Memoize<TSource>(IAsyncEnumerable<TSource>) | Creates a sequence that lazily caches the source as it is iterated for the first time, reusing the cache thereafter for future re-iterations. By default, all sequences are cached, whether they are instantiated or lazy. |
| MinByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the minimum value of a sequence. |
| MinByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the minimum value of a sequence. |
| MinItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the minimum value of a sequence. |
| MinItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the minimum value of a sequence. |
| MinItems<T>(IAsyncEnumerable<T>) | Returns all of the items that share the minimum value of a sequence. |
| MinItems<T>(IAsyncEnumerable<T>, IComparer<T>?) | Returns all of the items that share the minimum value of a sequence. |
| OnErrorResumeNext<TSource>(IAsyncEnumerable<IAsyncEnumerable<TSource>>) | Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. |
| OnErrorResumeNext<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>) | Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. |
| OnErrorResumeNext<TSource>(params IAsyncEnumerable<TSource>[]) | Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. |
| OnErrorResumeNext<TSource>(IEnumerable<IAsyncEnumerable<TSource>>) | Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. |
| OrderBy<T, TKey>(IAsyncEnumerable<T>, Func<T, TKey>, OrderByDirection) | Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key |
| OrderBy<T, TKey>(IAsyncEnumerable<T>, Func<T, TKey>, IComparer<TKey>, OrderByDirection) | Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key |
| PadStart<TSource>(IAsyncEnumerable<TSource>, int) | Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width. |
| PadStart<TSource>(IAsyncEnumerable<TSource>, int, Func<int, TSource>) | Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter in length) than a given width. An additional parameter specifies the function to calculate padding. |
| PadStart<TSource>(IAsyncEnumerable<TSource>, int, TSource) | Pads a sequence with a given filler value in the beginning if it is narrower (shorter in length) than a given width. An additional parameter specifies the value to use for padding. |
| Pad<TSource>(IAsyncEnumerable<TSource>, int) | Pads a sequence with default values if it is narrower (shorter in length) than a given width. |
| Pad<TSource>(IAsyncEnumerable<TSource>, int, Func<int, TSource>) | Pads a sequence with a dynamic filler value if it is narrower (shorter in length) than a given width. |
| Pad<TSource>(IAsyncEnumerable<TSource>, int, TSource) | Pads a sequence with a given filler value if it is narrower (shorter in length) than a given width. |
| PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>) | Executes a partial sort of the top |
| PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection) | Executes a |
| PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?) | Executes a partial sort of the top |
| PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection) | Executes a |
| PartialSort<T>(IAsyncEnumerable<T>, int) | Executes a partial sort of the top |
| PartialSort<T>(IAsyncEnumerable<T>, int, OrderByDirection) | Executes a |
| PartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?) | Executes a partial sort of the top |
| PartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?, OrderByDirection) | Executes a |
| Partition<T>(IAsyncEnumerable<T>, Func<T, bool>, CancellationToken) | Partitions or splits a sequence in two using a predicate. |
| Partition<T, TResult>(IAsyncEnumerable<T>, Func<T, bool>, Func<IEnumerable<T>, IEnumerable<T>, TResult>, CancellationToken) | Partitions or splits a sequence in two using a predicate and then projects a result from the two. |
| PreScan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>, TSource) | Performs a pre-scan (exclusive prefix sum) on a sequence of elements. |
| Publish<TSource>(IAsyncEnumerable<TSource>) | Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of the sequence from the current index in the buffer. |
| Random() | Returns an infinite sequence of random integers using the standard .NET random number generator. |
| Random(int) | Returns an infinite sequence of random integers between zero and a given maximum. |
| Random(int, int) | Returns an infinite sequence of random integers between a given minimum and a maximum. |
| Random(Random) | Returns an infinite sequence of random integers using the supplied random number generator. |
| Random(Random, int) | Returns an infinite sequence of random integers between zero and a given maximum using the supplied random number generator. |
| Random(Random, int, int) | Returns an infinite sequence of random integers between a given minumum and a maximum using the supplied random number generator. |
| RandomDouble() | Returns an infinite sequence of random double values between 0.0 and 1.0 |
| RandomDouble(Random) | Returns an infinite sequence of random double values between 0.0 and 1.0 using the supplied random number generator. |
| Range(int, int, int) | Generates a sequence of integral numbers within a specified range. |
| RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>) | Ranks each item in the sequence in ascending order by a specified key using a default comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) | Ranks each item in the sequence in ascending order by a specified key using a caller-supplied comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Rank<TSource>(IAsyncEnumerable<TSource>) | Ranks each item in the sequence in ascending order using a default comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| Rank<TSource>(IAsyncEnumerable<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Rank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>) | Ranks each item in the sequence in ascending order using a caller-supplied comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| Rank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Repeat<TSource>(IAsyncEnumerable<TSource>) | Repeats and concatenates the source sequence infinitely. |
| Repeat<TSource>(IAsyncEnumerable<TSource>, int) | Repeats and concatenates the source sequence the given number of times. |
| Repeat<TResult>(TResult) | Generates a sequence by repeating the given value infinitely. |
| Replace<TSource>(IAsyncEnumerable<TSource>, Index, TSource) | Replaces a single value in a sequence at a specified index with the given replacement value. |
| Replace<TSource>(IAsyncEnumerable<TSource>, int, TSource) | Replaces a single value in a sequence at a specified index with the given replacement value. |
| Retry<TSource>(IAsyncEnumerable<TSource>) | Creates a sequence that retries enumerating the source sequence as long as an error occurs. |
| Retry<TSource>(IAsyncEnumerable<TSource>, int) | Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. |
| Return<T>(T) | Returns a single-element sequence containing the item provided. |
| RightOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RunLengthEncode<T>(IAsyncEnumerable<T>) | Run-length encodes a sequence by converting consecutive instances of the same element into a tuple representing the item and its occurrence count. |
| RunLengthEncode<T>(IAsyncEnumerable<T>, IEqualityComparer<T>?) | Run-length encodes a sequence by converting consecutive instances of the same element into a tuple representing the item and its occurrence count. This overload uses a custom equality comparer to identify equivalent items. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TKey>>, Func<TKey, CancellationToken, ValueTask<TState>>, Func<TState, TKey, TSource, CancellationToken, ValueTask<TState>>) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TKey>>, Func<TKey, CancellationToken, ValueTask<TState>>, Func<TState, TKey, TSource, CancellationToken, ValueTask<TState>>, IEqualityComparer<TKey>?) | 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. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, Func<TKey, ValueTask<TState>>, Func<TState, TKey, TSource, ValueTask<TState>>) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, Func<TKey, ValueTask<TState>>, Func<TState, TKey, TSource, ValueTask<TState>>, IEqualityComparer<TKey>?) | 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. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. |
| ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>, IEqualityComparer<TKey>?) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. An additional parameter specifies the comparer to use to compare keys. |
| ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, CancellationToken, ValueTask<TSource>>) | Performs a right-associative scan (inclusive prefix) on a sequence of elements. This operator is the right-associative version of the Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, ValueTask<TSource>>) | Performs a right-associative scan (inclusive prefix) on a sequence of elements. This operator is the right-associative version of the Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) | Performs a right-associative scan (inclusive prefix) on a sequence of elements. This operator is the right-associative version of the Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<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 Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>) LINQ operator. |
| ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<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 Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>) LINQ operator. |
| ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, 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 Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>) LINQ operator. |
| Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) | Performs a scan (inclusive prefix sum) on a sequence of elements. This operator is similar to Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) except that Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>) returns the sequence of intermediate results as well as the final one. |
| Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>) | Performs a scan (inclusive prefix sum) on a sequence of elements. This operator is similar to Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) except that Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>) returns the sequence of intermediate results as well as the final one. |
| Segment<T>(IAsyncEnumerable<T>, Func<T, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IAsyncEnumerable<T>, Func<T, int, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IAsyncEnumerable<T>, Func<T, int, ValueTask<bool>>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IAsyncEnumerable<T>, Func<T, T, int, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IAsyncEnumerable<T>, Func<T, T, int, ValueTask<bool>>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Sequence(int, int) | Generates a sequence of integral numbers within the (inclusive) specified range. If sequence is ascending the step is +1, otherwise -1. |
| Sequence(int, int, int) | Generates a sequence of integral numbers within the (inclusive) specified range. An additional parameter specifies the steps in which the integers of the sequence increase or decrease. |
| Share<TSource>(IAsyncEnumerable<TSource>) | Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element from the source sequence. |
| SkipUntil<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>) | Skips items from the input sequence until the given predicate returns true when applied to the current source item; that item will be the last skipped. |
| SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, IComparer<TKey>?, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMerge<TSource>(IAsyncEnumerable<TSource>, OrderByDirection, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| SortedMerge<TSource>(IAsyncEnumerable<TSource>, OrderByDirection, IComparer<TSource>?, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| SortedMerge<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| SortedMerge<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>?, params IAsyncEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| Split<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>) | Splits the source sequence by separator elements identified by a function. |
| Split<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, int) | Splits the source sequence by separator elements identified by a function, given a maximum count of splits. |
| Split<TSource>(IAsyncEnumerable<TSource>, TSource) | Splits the source sequence by a separator. |
| Split<TSource>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?) | Splits the source sequence by a separator and then transforms the splits into results. |
| Split<TSource>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int) | Splits the source sequence by a separator, given a maximum count of splits. A parameter specifies how the separator is compared for equality. |
| Split<TSource>(IAsyncEnumerable<TSource>, TSource, int) | Splits the source sequence by a separator given a maximum count of splits. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by separator elements identified by a function and then transforms the splits into results. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool>, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by separator elements identified by a function, given a maximum count of splits, and then transforms the splits into results. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator and then transforms the splits into results. A parameter specifies how the separator is compared for equality. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results. A parameter specifies how the separator is compared for equality. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator and then transforms the splits into results. |
| Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results. |
| StartsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, IEqualityComparer<T>?, CancellationToken) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| StartsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, CancellationToken) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| StartsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?, CancellationToken) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| StartsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, CancellationToken) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| TagFirstLast<TSource>(IAsyncEnumerable<TSource>) | 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. |
| TagFirstLast<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool, bool, TResult>) | Returns a sequence resulting from applying a function to each element in the source sequence with additional parameters indicating whether the element is the first and/or last of the sequence. |
| TakeEvery<TSource>(IAsyncEnumerable<TSource>, int) | Returns every N-th element of a sequence. |
| TakeUntil<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>) | 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. |
| Take<TSource>(IAsyncEnumerable<TSource>, Range) | Returns a specified range of contiguous elements from a sequence. |
| ThenBy<T, TKey>(IOrderedAsyncEnumerable<T>, Func<T, TKey>, OrderByDirection) | Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key |
| ThenBy<T, TKey>(IOrderedAsyncEnumerable<T>, Func<T, TKey>, IComparer<TKey>, OrderByDirection) | Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key |
| Throw<TSource>(Exception) | Returns a sequence that throws an exception upon enumeration. |
| Timeout<TSource>(IAsyncEnumerable<TSource>, TimeSpan) | Applies a timeout policy for each element in the async-enumerable sequence. If the next element isn't received within the specified timeout duration, a TimeoutException is propagated to the consumer. |
| TraverseBreadthFirst<T>(T, Func<T, IAsyncEnumerable<T>>) | Traverses a tree in a breadth-first fashion, starting at a root node and using a user-defined function to get the children at each node of the tree. |
| TraverseDepthFirst<T>(T, Func<T, IAsyncEnumerable<T>>) | Traverses a tree in a depth-first fashion, starting at a root node and using a user-defined function to get the children at each node of the tree. |
| TrySingle<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the single element in the sequence if it contains exactly one element. Similar to SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken). |
| TrySingle<T, TCardinality>(IAsyncEnumerable<T>, TCardinality, TCardinality, TCardinality, CancellationToken) | Returns a tuple with the cardinality of the sequence and the single element in the sequence if it contains exactly one element. similar to SingleAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken). |
| TrySingle<T, TCardinality, TResult>(IAsyncEnumerable<T>, TCardinality, TCardinality, TCardinality, Func<TCardinality, T?, TResult>, CancellationToken) | Returns a result projected from the the cardinality of the sequence and the single element in the sequence if it contains exactly one element. |
| Using<TSource, TResource>(Func<TResource>, Func<TResource, IAsyncEnumerable<TSource>>) | Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. |
| WhereLag<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLag<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, ValueTask<bool>>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLag<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLag<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<bool>>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLead<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| WhereLead<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, ValueTask<bool>>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| WhereLead<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| WhereLead<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<bool>>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| Where<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<bool>) | Filters a sequence of values based on an enumeration of boolean values |
| While<TSource>(Func<bool>, IAsyncEnumerable<TSource>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. |
| While<TSource>(Func<ValueTask<bool>>, IAsyncEnumerable<TSource>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. |
| WindowLeft<TSource>(IAsyncEnumerable<TSource>, int) | Creates a left-aligned sliding window of a given size over the source sequence. |
| WindowRight<TSource>(IAsyncEnumerable<TSource>, int) | Creates a right-aligned sliding window over the source sequence of a given size. |
| Window<TSource>(IAsyncEnumerable<TSource>, int) | Processes a sequence into a series of subsequences representing a windowed subset of the original |
| ZipLongest<T1, T2>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, Func<T1?, T2?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, T4>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, IAsyncEnumerable<T4>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, Func<T1?, T2?, T3?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, T4, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, IAsyncEnumerable<T4>, Func<T1?, T2?, T3?, T4?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TResult>>) | Applies a function to each element in a sequence and returns a sequence of tuples containing both the original item as well as the function result. |
| ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TResult>>) | Applies a function to each element in a sequence and returns a sequence of tuples containing both the original item as well as the function result. |
| ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TResult>) | Applies a function to each element in a sequence and returns a sequence of tuples containing both the original item as well as the function result. |
| ZipShortest<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TThird>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst, TSecond, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |
| ZipShortest<TFirst, TSecond, TThird, TFourth>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TThird, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |
| ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |