Try your search with a different keyword or use * as a wildcard.
namespace System.Linq;
public static class AsyncIEnumerableExtensions
{
/// <summary>
/// Projects each element of an async-enumerable sequence into a new form by applying
/// an asynchronous selector function to each member of the source sequence and awaiting
/// the result.
/// </summary>
/// <typeparam name="TSource"> The type of the elements in the source sequence</typeparam>
/// <typeparam name="TResult">
/// The type of the elements in the result sequence, obtained by running the selector
/// function for each element in the source sequence and awaiting the result.
/// </typeparam>
/// <param name="source">A sequence of elements to invoke a transform function on</param>
/// <param name="predicate">An asynchronous transform function to apply to each source element</param>
/// <returns>
/// An async-enumerable sequence whose elements are the result of invoking the transform
/// function on each element of the source sequence and awaiting the result
/// </returns>
public static IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<TResult>> predicate)
{
return source.ToAsyncEnumerable().SelectAwait(predicate);
}
/// <summary>
/// Returns the first element of an async-enumerable sequence that satisfies the
/// condition in the predicate, or a default value if no element satisfies the condition
/// in the predicate
/// </summary>
/// <typeparam name="TSource">The type of element in the sequence</typeparam>
/// <param name="source">Source sequence</param>
/// <param name="predicate">An asynchronous predicate to invoke and await on each element of the sequence</param>
/// <returns>
/// A Task containing the first element in the sequence that satisfies the predicate,
/// or a default value if no element satisfies the predicate
/// </returns>
/// <returns>A task that represents the asynchronous operation</returns>
public static Task<TSource> FirstOrDefaultAwaitAsync<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<bool>> predicate)
{
return source.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(predicate).AsTask();
}
/// <summary>
/// Determines whether all elements in an async-enumerable sequence satisfy a condition
/// </summary>
/// <typeparam name="TSource">The type of element in the sequence</typeparam>
/// <param name="source">An sequence whose elements to apply the predicate to</param>
/// <param name="predicate">An asynchronous predicate to apply to each element of the source sequence</param>
/// <returns>
/// A Task containing a value indicating whether all elements in the sequence
/// pass the test in the specified predicate
/// </returns>
/// <returns>A task that represents the asynchronous operation</returns>
public static Task<bool> AllAwaitAsync<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<bool>> predicate)
{
return source.ToAsyncEnumerable().AllAwaitAsync(predicate).AsTask();
}
/// <summary>
/// Projects each element of an async-enumerable sequence into an async-enumerable
/// sequence and merges the resulting async-enumerable sequences into one async-enumerable
/// sequence
/// </summary>
/// <typeparam name="TSource">The type of elements in the source sequence</typeparam>
/// <typeparam name="TResult">The type of elements in the projected inner sequences and the merged result sequence</typeparam>
/// <param name="source">An async-enumerable sequence of elements to project</param>
/// <param name="predicate">An asynchronous selector function to apply to each element of the source sequence</param>
/// <returns>
/// An async-enumerable sequence whose elements are the result of invoking the one-to-many
/// transform function on each element of the source sequence and awaiting the result
/// </returns>
public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IEnumerable<TSource> source,
Func<TSource, Task<IList<TResult>>> predicate)
{
async ValueTask<IAsyncEnumerable<TResult>> getAsyncEnumerable(TSource items)
{
var rez = await predicate(items);
return rez.ToAsyncEnumerable();
}
return source.ToAsyncEnumerable().SelectManyAwait(getAsyncEnumerable);
}
/// <summary>
/// Projects each element of an async-enumerable sequence into an async-enumerable
/// sequence and merges the resulting async-enumerable sequences into one async-enumerable
/// sequence
/// </summary>
/// <typeparam name="TSource">The type of elements in the source sequence</typeparam>
/// <typeparam name="TResult">The type of elements in the projected inner sequences and the merged result sequence</typeparam>
/// <param name="source">An async-enumerable sequence of elements to project</param>
/// <param name="predicate">An asynchronous selector function to apply to each element of the source sequence</param>
/// <returns>
/// An async-enumerable sequence whose elements are the result of invoking the one-to-many
/// transform function on each element of the source sequence and awaiting the result
/// </returns>
public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IEnumerable<TSource> source,
Func<TSource, Task<IEnumerable<TResult>>> predicate)
{
async ValueTask<IAsyncEnumerable<TResult>> getAsyncEnumerable(TSource items)
{
var rez = await predicate(items);
return rez.ToAsyncEnumerable();
}
return source.ToAsyncEnumerable().SelectManyAwait(getAsyncEnumerable);
}
/// <summary>
/// Filters the elements of an async-enumerable sequence based on an asynchronous
/// predicate
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source">An async-enumerable sequence whose elements to filter</param>
/// <param name="predicate">An asynchronous predicate to test each source element for a condition</param>
/// <returns>
/// An async-enumerable sequence that contains elements from the input sequence that
/// satisfy the condition
/// </returns>
public static IAsyncEnumerable<TSource> WhereAwait<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<bool>> predicate)
{
return source.ToAsyncEnumerable().WhereAwait(predicate);
}
/// <summary>
/// Determines whether any element in an async-enumerable sequence satisfies a condition
/// </summary>
/// <typeparam name="TSource">The type of element in the sequence</typeparam>
/// <param name="source">An async-enumerable sequence whose elements to apply the predicate to</param>
/// <param name="predicate">An asynchronous predicate to apply to each element of the source sequence</param>
/// <returns>
/// A Task containing a value indicating whether any elements in the source
/// sequence pass the test in the specified predicate
/// </returns>
/// <returns>A task that represents the asynchronous operation</returns>
public static Task<bool> AnyAwaitAsync<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<bool>> predicate)
{
return source.ToAsyncEnumerable().AnyAwaitAsync(predicate).AsTask();
}
/// <summary>
/// Returns the only element of an async-enumerable sequence that satisfies the condition
/// in the asynchronous predicate, or a default value if no such element exists,
/// and reports an exception if there is more than one element in the async-enumerable
/// sequence that matches the predicate
/// </summary>
/// <typeparam name="TSource">The type of elements in the source sequence</typeparam>
/// <param name="source">Source async-enumerable sequence</param>
/// <param name="predicate">An asynchronous predicate that will be applied to each element of the source sequence</param>
/// <returns>
/// Task containing the only element in the async-enumerable sequence that satisfies
/// the condition in the asynchronous predicate, or a default value if no such element
/// exists
/// </returns>
/// <returns>A task that represents the asynchronous operation</returns>
public static Task<TSource> SingleOrDefaultAwaitAsync<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<bool>> predicate)
{
return source.ToAsyncEnumerable().SingleOrDefaultAwaitAsync(predicate).AsTask();
}
/// <summary>
/// Creates a list from an async-enumerable sequence
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
/// <param name="source">The source async-enumerable sequence to get a list of elements for</param>
/// <returns>
/// An async-enumerable sequence containing a single element with a list containing
/// all the elements of the source sequence
/// </returns>
/// <returns>A task that represents the asynchronous operation</returns>
public static Task<List<TSource>> ToListAsync<TSource>(this IEnumerable<TSource> source)
{
return source.ToAsyncEnumerable().ToListAsync().AsTask();
}
/// <summary>
/// Sorts the elements of a sequence in descending order according to a key obtained
/// by invoking a transform function on each element and awaiting the result
/// </summary>
/// <typeparam name="TSource">The type of the elements of source</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector</typeparam>
/// <param name="source">An async-enumerable sequence of values to order</param>
/// <param name="keySelector">An asynchronous function to extract a key from an element</param>
/// <returns>
/// An ordered async-enumerable sequence whose elements are sorted in descending
/// order according to a key
/// </returns>
public static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(
this IEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
{
return source.ToAsyncEnumerable().OrderByDescendingAwait(keySelector);
}
/// <summary>
/// Groups the elements of an async-enumerable sequence and selects the resulting
/// elements by using a specified function
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
/// <typeparam name="TKey">The type of the grouping key computed for each element in the source sequence</typeparam>
/// <typeparam name="TElement">The type of the elements within the groups computed for each element in the source sequence</typeparam>
/// <param name="source">An async-enumerable sequence whose elements to group</param>
/// <param name="keySelector">An asynchronous function to extract the key for each element</param>
/// <param name="elementSelector">An asynchronous function to map each source element to an element in an async-enumerable group</param>
/// <returns>
/// A sequence of async-enumerable groups, each of which corresponds to a unique
/// key value, containing all elements that share that same key value
/// </returns>
public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(
this IEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector,
Func<TSource, ValueTask<TElement>> elementSelector)
{
return source.ToAsyncEnumerable().GroupByAwait(keySelector, elementSelector);
}
/// <summary>
/// Applies an accumulator function over an async-enumerable sequence, returning
/// the result of the aggregation as a single element in the result sequence. The
/// specified seed value is used as the initial accumulator value
/// </summary>
/// <typeparam name="TSource">specified seed value is used as the initial accumulator value</typeparam>
/// <typeparam name="TAccumulate">The type of the result of aggregation</typeparam>
/// <param name="source">An async-enumerable sequence to aggregate over</param>
/// <param name="seed">The initial accumulator value</param>
/// <param name="accumulator">An asynchronous accumulator function to be invoked and awaited on each element</param>
/// <returns>A Task containing the final accumulator value</returns>
public static ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(
this IEnumerable<TSource> source, TAccumulate seed,
Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator)
{
return source.ToAsyncEnumerable().AggregateAwaitAsync(seed, accumulator);
}
/// <summary>
/// Creates a dictionary from an async-enumerable sequence using the specified asynchronous
/// key and element selector functions
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
/// <typeparam name="TKey">The type of the dictionary key computed for each element in the source sequence</typeparam>
/// <typeparam name="TElement">The type of the dictionary value computed for each element in the source sequence</typeparam>
/// <param name="source">An async-enumerable sequence to create a dictionary for</param>
/// <param name="keySelector">An asynchronous function to extract a key from each element</param>
/// <param name="elementSelector">An asynchronous transform function to produce a result element value from each element</param>
/// <returns>
/// A Task containing a dictionary mapping unique key values onto the corresponding
/// source sequence's element
/// </returns>
public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(
this IEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector,
Func<TSource, ValueTask<TElement>> elementSelector) where TKey : notnull
{
return source.ToAsyncEnumerable().ToDictionaryAwaitAsync(keySelector, elementSelector);
}
/// <summary>
/// Groups the elements of an async-enumerable sequence according to a specified
/// key selector function
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
/// <typeparam name="TKey">The type of the grouping key computed for each element in the source sequence</typeparam>
/// <param name="source">An async-enumerable sequence whose elements to group</param>
/// <param name="keySelector">An asynchronous function to extract the key for each element</param>
/// <returns>
/// A sequence of async-enumerable groups, each of which corresponds to a unique
/// key value, containing all elements that share that same key value
/// </returns>
public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
{
return source.ToAsyncEnumerable().GroupByAwait(keySelector);
}
/// <summary>
/// Computes the sum of a sequence of System.Decimal values that are obtained by
/// invoking a transform function on each element of the source sequence and awaiting
/// the result
/// </summary>
/// <typeparam name="TSource">The type of elements in the source sequence</typeparam>
/// <param name="source">A sequence of values that are used to calculate a sum</param>
/// <param name="selector">An asynchronous transform function to apply to each element</param>
/// <returns>A Task containing the sum of the values in the source sequence</returns>
public static ValueTask<decimal> SumAwaitAsync<TSource>(this IEnumerable<TSource> source,
Func<TSource, ValueTask<decimal>> selector)
{
return source.ToAsyncEnumerable().SumAwaitAsync(selector);
}
}