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); } }