static WhereSelectEnumerable <TEnumerable, TEnumerator, TSource, TResult> WhereSelect <TEnumerable, TEnumerator, TSource, TResult>(
this TEnumerable source,
AsyncPredicate <TSource> predicate,
AsyncSelector <TSource, TResult> selector)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> new WhereSelectEnumerable <TEnumerable, TEnumerator, TSource, TResult>(in source, predicate, selector);
public static async Task <bool> ExistsAsync <T>(this IEnumerable <T> col, AsyncPredicate <T> predicate)
{
foreach (var entry in col)
{
if (await predicate(entry))
{
return(true);
}
}
return(false);
}
static async ValueTask <bool> ExecuteAsync(TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (!await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false))
{
return(false);
}
}
return(true);
}
}
public static async Task <bool> RetryAsync(AsyncPredicate predicate, int tryCount, int tryDelay = 1000, bool throwException = false)
{
do
{
try
{
if (await predicate())
{
return(true);
}
}
catch (Exception)
{
if (throwException)
{
throw;
}
}
await Task.Delay(tryDelay);
} while (tryCount-- > 0);
return(false);
}
static async ValueTask <List <TSource> > ToListAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
var list = new List <TSource>();
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
var item = enumerator.Current;
if (await predicate(item, cancellationToken).ConfigureAwait(false))
{
list.Add(item);
}
}
return(list);
}
}
public static WhereEnumerable <TEnumerable, TEnumerator, TSource> Where <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
if (predicate is null)
{
Throw.ArgumentNullException(nameof(predicate));
}
return(new WhereEnumerable <TEnumerable, TEnumerator, TSource>(in source, predicate));
}
public static async Task <OperationResult <T> > ContinueOnSuccessWhenAsync <T>(this Task <OperationResult <T> > prevOperationResult, AsyncPredicate <T> condition, AsyncFunc <T, OperationResult <T> > nextOperation) => await(await prevOperationResult) .ContinueOnSuccessWhenAsync(condition, nextOperation);
public static Task <OperationResult <T> > ContinueOnSuccessWhenAsync <T>(this OperationResult <T> prevOperationResult, AsyncPredicate <T> condition, AsyncFunc <T, OperationResult <T> > nextOperation)
=> prevOperationResult
.ContinueWhenAsync(async x => x.IsSuccess && await condition.AssertNotNull(nameof(condition))
.Invoke(prevOperationResult.Value),
x => nextOperation.AssertNotNull(nameof(nextOperation))
.Invoke(prevOperationResult.Value));
public static Task <OperationResult> RequireOnSuccessAsync(this OperationResult currentOperationResult, AsyncPredicate condition, AsyncFunc <IOperationError> errorBuilder)
=> currentOperationResult
.DoOnSuccessWhenAsync(async() => !await condition.AssertNotNull(nameof(condition))
.Invoke(),
async() => OperationResult.FromError(await errorBuilder.AssertNotNull(nameof(errorBuilder))
.Invoke()));
static async ValueTask <TSource[]> ToArrayAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> (await ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource>(source, predicate, ArrayPool <TSource> .Shared, cancellationToken).ConfigureAwait(false)).ToArray();
static async ValueTask <TResult[]> ToArrayAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var builder = new LargeArrayBuilder <TResult>(initialize: true);
await builder.AddRangeAsync <TEnumerable, TEnumerator, TSource>(source, predicate, selector, cancellationToken).ConfigureAwait(false);
return(builder.ToArray());
}
public async ValueTask AddRangeAsync <TEnumerable, TEnumerator, U>(TEnumerable items, AsyncPredicate <U> predicate, AsyncSelector <U, T> selector, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <U, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <U>
{
Debug.Assert(items is object);
var enumerator = items.GetAsyncEnumerator();
await using (enumerator.ConfigureAwait(false))
{
var destination = _current;
var index = _index;
// Continuously read in items from the enumerator, updating _count
// and _index when we run out of space.
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
var item = enumerator.Current;
if (await predicate(item, cancellationToken).ConfigureAwait(false))
{
if ((uint)index >= (uint)destination.Length)
{
AddWithBufferAllocation(await selector(item, cancellationToken).ConfigureAwait(false), ref destination, ref index);
}
else
{
destination[index] = await selector(item, cancellationToken).ConfigureAwait(false);
}
index++;
}
}
// Final update to _count and _index.
_count += index - _index;
_index = index;
}
}
static async ValueTask <int> CountAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var count = 0;
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
checked
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
var result = await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false);
count += Unsafe.As <bool, byte>(ref result);
}
}
}
return(count);
}
public static async Task <OperationResult <T> > ContinueOnFailureWhenAsync <T>(this Task <OperationResult <T> > prevOperationResult, AsyncPredicate <IOperationError> condition, AsyncFunc <IOperationError, OperationResult <T> > nextOperation) => await(await prevOperationResult) .ContinueOnFailureWhenAsync(condition, nextOperation);
public static Task <OperationResult <T> > ContinueOnFailureWhenAsync <T>(this OperationResult <T> prevOperationResult, AsyncPredicate <IOperationError> condition, AsyncFunc <IOperationError, OperationResult <T> > nextOperation)
=> prevOperationResult
.ContinueWhenAsync(async x => x.IsFailure && await condition.AssertNotNull(nameof(condition))
.Invoke(x.Error),
x => nextOperation.AssertNotNull(nameof(nextOperation))
.Invoke(x.Error));
public static Task <OperationResult <T> > ContinueOnFailureWhenAsync <T>(this OperationResult <T> prevOperationResult, AsyncPredicate condition, Func <OperationResult <T> > nextOperation)
=> prevOperationResult
.ContinueWhenAsync(async x => x.IsFailure && await condition.AssertNotNull(nameof(condition))
.Invoke(),
nextOperation);
static IPropertyValidator CreateAsyncValidator(AsyncPredicate predicate)
{
return(new AsyncPredicateValidator(predicate));
}
public static Task <OperationResult <T> > BranchOnFailureWhenAsync <T>(this OperationResult <T> currentOperationResult, AsyncPredicate condition, Action branchAction)
=> currentOperationResult
.BranchWhenAsync(async x => x.IsFailure && await condition.AssertNotNull(nameof(condition))
.Invoke(),
branchAction);
public static ValueTask <bool> AllAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken = default)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
if (predicate is null)
{
Throw.ArgumentNullException(nameof(predicate));
}
cancellationToken.ThrowIfCancellationRequested();
return(ExecuteAsync(source, predicate, cancellationToken));
public static async Task <OperationResult> BranchOnFailureWhenAsync(this Task <OperationResult> currentOperationResult, AsyncPredicate condition, AsyncAction branchAction) => await(await currentOperationResult) .BranchOnFailureWhenAsync(condition, branchAction);
static async ValueTask <IMemoryOwner <TResult> > ToArrayAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, MemoryPool <TResult> pool, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> (await ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(source, predicate, selector, ArrayPool <TResult> .Shared, cancellationToken).ConfigureAwait(false)).ToArray(pool);
public static async Task <OperationResult <T> > RequireOnSuccessAsync <T>(this Task <OperationResult <T> > currentOperationResult, AsyncPredicate <T> condition, AsyncFunc <T, IOperationError> errorBuilder) => await(await currentOperationResult) .RequireOnSuccessAsync(condition, errorBuilder);
public static Task <OperationResult <T> > BranchOnFailureWhenAsync <T>(this OperationResult <T> currentOperationResult, AsyncPredicate <IOperationError> condition, AsyncAction <IOperationError> branchAction)
=> currentOperationResult
.BranchWhenAsync(async x => x.IsFailure && await condition.AssertNotNull(nameof(condition))
.Invoke(x.Error),
x => branchAction.AssertNotNull(nameof(branchAction))
.Invoke(x.Error));
static async ValueTask <bool> ContainsAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, TSource value, IEqualityComparer <TSource>?comparer, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
if (comparer is null)
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false) &&
EqualityComparer <TSource> .Default.Equals(enumerator.Current, value))
{
return(true);
}
}
}
else
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false) &&
comparer.Equals(enumerator.Current, value))
{
return(true);
}
}
}
}
return(false);
}
public static async Task <OperationResult <T> > BranchOnFailureWhenAsync <T>(this Task <OperationResult <T> > currentOperationResult, AsyncPredicate <IOperationError> condition, AsyncAction <IOperationError> branchAction) => await(await currentOperationResult) .BranchOnFailureWhenAsync(condition, branchAction);
static ValueTask <Option <TSource> > SingleAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken = default)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> GetSingleAsync <TEnumerable, TEnumerator, TSource>(source, predicate, cancellationToken);
public static async Task <OperationResult> ContinueOnSuccessWhenAsync(this Task <OperationResult> prevOperationResult, AsyncPredicate condition, Func <OperationResult> nextOperation) => await(await prevOperationResult) .ContinueOnSuccessWhenAsync(condition, nextOperation);
static async ValueTask <Option <TResult> > SingleAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken = default)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var option = await GetSingleAsync <TEnumerable, TEnumerator, TSource>(source, predicate, cancellationToken).ConfigureAwait(false);
return(await option.SelectAsync(selector, cancellationToken).ConfigureAwait(false));
}
public static Task <OperationResult> ContinueOnSuccessWhenAsync(this OperationResult prevOperationResult, AsyncPredicate condition, AsyncFunc <OperationResult> nextOperation)
=> prevOperationResult
.ContinueWhenAsync(async x => x.IsSuccess && await condition.AssertNotNull(nameof(condition))
.Invoke(),
nextOperation);
static async ValueTask <Option <TSource> > GetSingleAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicate <TSource> predicate, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false))
{
var value = enumerator.Current;
// found first, keep going until end or find second
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false))
{
return(Option.None);
}
}
return(Option.Some(value));
}
}
return(Option.None);
}
}
