/// <summary> /// Applies specified action to each collection element asynchronously. /// </summary> /// <typeparam name="T">Type of elements in the collection.</typeparam> /// <param name="collection">A collection to enumerate. Cannot be <see langword="null"/>.</param> /// <param name="action">An action to applied for each element.</param> /// <param name="token">The token that can be used to cancel the enumeration.</param> /// <returns>The task representing asynchronous execution of this method.</returns> /// <exception cref="OperationCanceledException">The enumeration has been canceled.</exception> public static async ValueTask ForEachAsync <T>(this IAsyncEnumerable <T> collection, ValueFunc <T, CancellationToken, ValueTask> action, CancellationToken token = default) { await foreach (var item in collection.WithCancellation(token)) { await action.Invoke(item, token).ConfigureAwait(false); } }
internal async void Execute(TimeSpan dueTime, TimeSpan period, ValueFunc <CancellationToken, Task <bool> > callback) { try { await System.Threading.Tasks.Task.Delay(dueTime, cancellation.Token).ConfigureAwait(false); while (await callback.Invoke(cancellation.Token).ConfigureAwait(false)) { await System.Threading.Tasks.Task.Delay(period, cancellation.Token).ConfigureAwait(false); } TrySetResult(true); } catch (OperationCanceledException) { TrySetResult(false); } catch (Exception e) { TrySetException(e); } finally { cancellation.Dispose(); } }
/// <summary> /// Returns the first element in a sequence that satisfies a specified condition. /// </summary> /// <typeparam name="T">The type of the elements of source.</typeparam> /// <param name="seq">A collection to return an element from.</param> /// <param name="filter">A function to test each element for a condition.</param> /// <param name="token">The token that can be used to cancel enumeration.</param> /// <returns>The first element in the sequence that matches to the specified filter; or empty value.</returns> /// <exception cref="OperationCanceledException">The operation has been canceled.</exception> public static async ValueTask <Optional <T> > FirstOrEmptyAsync <T>(this IAsyncEnumerable <T> seq, ValueFunc <T, bool> filter, CancellationToken token = default) where T : notnull { await foreach (var item in seq.WithCancellation(token)) { if (filter.Invoke(item)) { return(item); } } return(Optional <T> .None); }
private void Execute() { try { switch (state) { case BeginInitState: voidAwaiter = System.Threading.Tasks.Task.Delay(dueTime, cancellation.Token).ConfigureAwait(false).GetAwaiter(); if (voidAwaiter.IsCompleted) { goto case EndInitState; } state = EndInitState; voidAwaiter.OnCompleted(continuation); break; case EndInitState: voidAwaiter.GetResult(); voidAwaiter = default; goto case BeginLoopState; case BeginLoopState: boolAwaiter = callback.Invoke(cancellation.Token).ConfigureAwait(false).GetAwaiter(); if (boolAwaiter.IsCompleted) { goto case EndLoopState; } state = EndLoopState; boolAwaiter.OnCompleted(continuation); break; case EndLoopState: var success = boolAwaiter.GetResult(); boolAwaiter = default; if (success) { goto case BeginDelayState; } TrySetResult(true); break; case BeginDelayState: voidAwaiter = System.Threading.Tasks.Task.Delay(period, cancellation.Token).ConfigureAwait(false).GetAwaiter(); if (voidAwaiter.IsCompleted) { goto case EndDelayState; } state = EndDelayState; voidAwaiter.OnCompleted(continuation); break; case EndDelayState: voidAwaiter.GetResult(); voidAwaiter = default; goto case BeginLoopState; } } catch (OperationCanceledException) { TrySetResult(false); } catch (Exception e) { TrySetException(e); } if (Task.IsCompleted) { cancellation.Dispose(); } }
public TResult Invoke(T item, int index) => selector.Invoke(item);
internal TWrapper WrapBuffer <TWrapper>(ValueFunc <T[], int, TWrapper> factory) => factory.Invoke(buffer, position);
public void Execute() { Output[0] = Func.Invoke(Input[0]); }