public static IAsyncObserver <TSource> Last <TSource>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var hasValue = false; var lastValue = default(TSource); return(Create <TSource>( x => { hasValue = true; lastValue = x; return default; }, observer.OnErrorAsync, async() => { if (!hasValue) { await observer.OnErrorAsync(new InvalidOperationException("The sequence is empty.")).ConfigureAwait(false); } else { await observer.OnNextAsync(lastValue).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } } )); }
public static ValueTask <IAsyncDisposable> Timer(IAsyncObserver <long> observer, DateTimeOffset dueTime, TimeSpan period, IAsyncScheduler scheduler) { if (period < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(period)); } if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } var tick = 0L; return(scheduler.ScheduleAsync(async ct => { if (ct.IsCancellationRequested) { return; } // TODO: Compensate for drift by adding stopwatch functionality. do { await observer.OnNextAsync(tick++).RendezVous(scheduler, ct); await scheduler.Delay(period, ct).RendezVous(scheduler, ct); } while (!ct.IsCancellationRequested); }, dueTime)); }
public static ValueTask <IAsyncDisposable> Range(IAsyncObserver <int> observer, int start, int count, IAsyncScheduler scheduler) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (count < 0 || ((long)start) + count - 1 > int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(count)); } if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } return(scheduler.ScheduleAsync(async ct => { if (ct.IsCancellationRequested) { return; } for (int i = start, end = start + count - 1; i <= end && !ct.IsCancellationRequested; i++) { await observer.OnNextAsync(i).RendezVous(scheduler, ct); } if (ct.IsCancellationRequested) { return; } await observer.OnCompletedAsync().RendezVous(scheduler, ct); })); }
public static Task <IAsyncDisposable> Return <TSource>(IAsyncObserver <TSource> observer, TSource value, IAsyncScheduler scheduler) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } return(scheduler.ScheduleAsync(async ct => { if (ct.IsCancellationRequested) { return; } await observer.OnNextAsync(value).RendezVous(scheduler, ct); if (ct.IsCancellationRequested) { return; } await observer.OnCompletedAsync().RendezVous(scheduler, ct); })); }
public static IAsyncObserver <TSource> SingleOrDefault <TSource>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var hasValue = false; var value = default(TSource); return(Create <TSource>( async x => { if (hasValue) { await observer.OnErrorAsync(new InvalidOperationException("The sequence contains more than one element.")).ConfigureAwait(false); return; } hasValue = true; value = x; }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(hasValue ? value : default(TSource)).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> Select <TSource, TResult>(IAsyncObserver <TResult> observer, Func <TSource, TResult> selector) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (selector == null) { throw new ArgumentNullException(nameof(selector)); } return(Create <TSource>( async x => { TResult res; try { res = selector(x); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnNextAsync(res).ConfigureAwait(false); }, observer.OnErrorAsync, observer.OnCompletedAsync )); }
public static IAsyncObserver <TSource> Count <TSource>(IAsyncObserver <int> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var count = 0; return(Create <TSource>( async x => { try { checked { count++; } } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(count).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> LastOrDefault <TSource>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var hasValue = false; var lastValue = default(TSource); return(Create <TSource>( x => { hasValue = true; lastValue = x; return Task.CompletedTask; }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(hasValue ? lastValue : default(TSource)).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> Scan <TSource, TResult>(IAsyncObserver <TResult> observer, TResult seed, Func <TResult, TSource, TResult> func) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (func == null) { throw new ArgumentNullException(nameof(func)); } var value = seed; return(Create <TSource>( async x => { try { value = func(value, x); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnNextAsync(value).ConfigureAwait(false); }, observer.OnErrorAsync, observer.OnCompletedAsync )); }
private Task NextItem(object item, StreamSequenceToken token) { T typedItem; try { typedItem = (T)item; } catch (InvalidCastException) { // We got an illegal item on the stream -- close it with a Cast exception throw new InvalidCastException("Received an item of type " + item.GetType().Name + ", expected " + typeof(T).FullName); } // This method could potentially be invoked after Dispose() has been called, // so we have to ignore the request or we risk breaking unit tests AQ_01 - AQ_04. if (observer == null || !IsValid) { return(TaskDone.Done); } if (filterWrapper != null && !filterWrapper.ShouldReceive(streamImpl, filterWrapper.FilterData, typedItem)) { return(TaskDone.Done); } return(observer.OnNextAsync(typedItem, token)); }
public async Task <IAsyncDisposable> SubscribeAsync(IAsyncObserver <T> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } bool hasValue; T value; bool done; Exception error; lock (_gate) { done = _done; error = _error; hasValue = _hasValue; value = _value; if (!done && error == null) { _observers.Add(observer); } } if (error != null) { await observer.OnErrorAsync(error).ConfigureAwait(false); return(AsyncDisposable.Nop); } else if (done) { if (hasValue) { await observer.OnNextAsync(value).ConfigureAwait(false); } await observer.OnCompletedAsync().ConfigureAwait(false); return(AsyncDisposable.Nop); } return(AsyncDisposable.Create(() => { lock (_gate) { var i = _observers.LastIndexOf(observer); if (i >= 0) { _observers.RemoveAt(i); } } return Task.CompletedTask; })); }
public ValueTask <bool> OnNextAsync(T value) { if (!_predicate(value)) { return(new ValueTask <bool>(true)); } return(_observer.OnNextAsync(value)); }
public static IAsyncObserver <TSource> Max <TSource>(IAsyncObserver <TSource> observer, IComparer <TSource> comparer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (comparer == null) { throw new ArgumentNullException(nameof(comparer)); } var max = default(TSource); var found = false; return(Create <TSource>( async x => { if (found) { bool isGreater; try { isGreater = comparer.Compare(x, max) > 0; } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } if (isGreater) { max = x; } } else { max = x; found = true; } }, observer.OnErrorAsync, async() => { if (!found) { await observer.OnErrorAsync(new InvalidOperationException("The sequence is empty.")).ConfigureAwait(false); } else { await observer.OnNextAsync(max).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } } )); }
public static (IAsyncObserver <TSource>, IAsyncObserver <TUntil>) SkipUntil <TSource, TUntil>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var gate = new AsyncLock(); var open = false; return ( Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { if (open) { await observer.OnNextAsync(x).ConfigureAwait(false); } } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnCompletedAsync().ConfigureAwait(false); } } ), Create <TUntil>( async y => { using (await gate.LockAsync().ConfigureAwait(false)) { open = true; } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, () => default ) ); }
/// <summary> /// Invokes the observer's method corresponding to the notification. /// </summary> /// <param name="observer">Observer to invoke the notification on.</param> /// <returns>Task indicating the completion of invoking the observer method.</returns> public override Task AcceptAsync(IAsyncObserver <T> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } return(observer.OnNextAsync(Value)); }
public async Task SendConnectionAsync(string methodName, object[] args) { if (State.Aborted) { throw new InvalidOperationException(nameof(State.Aborted)); } await _hubLifetimeManagerObserver.OnNextAsync(new ClientInvocationMessage(methodName, args, _connectionId)); }
public async ValueTask <bool> OnNextAsync(T value) { if (!await _predicate(value).ConfigureAwait(false)) { return(true); } return(await _observer.OnNextAsync(value).ConfigureAwait(false)); }
public static IAsyncObserver <TSource> Do <TSource>(IAsyncObserver <TSource> observer, IAsyncObserver <TSource> witness) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (witness == null) { throw new ArgumentNullException(nameof(witness)); } return(Create <TSource>( async x => { try { await witness.OnNextAsync(x).ConfigureAwait(false); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnNextAsync(x).ConfigureAwait(false); }, async error => { try { await witness.OnErrorAsync(error).ConfigureAwait(false); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnErrorAsync(error).ConfigureAwait(false); }, async() => { try { await witness.OnCompletedAsync().ConfigureAwait(false); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <int> AverageInt32(IAsyncObserver <double> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var sum = 0L; var count = 0L; return(Create <int>( async x => { try { checked { sum += x; count++; } } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, observer.OnErrorAsync, async() => { if (count > 0) { var res = default(double); try { checked { res = (double)sum / count; } } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } await observer.OnNextAsync(res).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } else { await observer.OnErrorAsync(new InvalidOperationException("The sequence is empty.")).ConfigureAwait(false); } } )); }
public async ValueTask <bool> OnNextAsync(T value) { if (_remaining > 0) { _remaining--; return(await _observer.OnNextAsync(value) && _remaining > 0); } return(false); }
private async Task GenerateEvents(string streamProviderName, Guid streamGuid, string streamNamespace, int produceCount) { IStreamProvider streamProvider = this.testHost.Client.GetStreamProvider(streamProviderName); IAsyncObserver <int> observer = streamProvider.GetStream <int>(streamGuid, streamNamespace); for (int i = 0; i < produceCount; i++) { await observer.OnNextAsync(i); } }
public static IAsyncObserver <TSource> TakeLastBuffer <TSource>(IAsyncObserver <IList <TSource> > observer, TimeSpan duration, IClock clock) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (duration < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(duration)); } if (clock == null) { throw new ArgumentNullException(nameof(clock)); } var queue = new Queue <Timestamped <TSource> >(); void Trim(DateTimeOffset now) { while (queue.Count > 0 && now - queue.Peek().Timestamp >= duration) { queue.Dequeue(); } } return(Create <TSource>( x => { var now = clock.Now; queue.Enqueue(new Timestamped <TSource>(x, now)); Trim(now); return Task.CompletedTask; }, observer.OnErrorAsync, async() => { Trim(clock.Now); var n = queue.Count; var res = new List <TSource>(n); while (queue.Count > 0) { res.Add(queue.Dequeue().Value); } await observer.OnNextAsync(res).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public ValueTask<bool> OnNextAsync(T value) { var sval = _selector(value); if (hasLastValue && _comparer.Equals(sval, lastValue)) return new ValueTask<bool>(true); hasLastValue = true; lastValue = sval; return _observer.OnNextAsync(value); }
public async ValueTask SubscribeAsync(IAsyncObserver <T> observer, CancellationToken token) { try { await observer.OnNextAsync(_value).ConfigureAwait(false); } finally { await observer.DisposeAsync().ConfigureAwait(false); } }
public ValueTask <bool> OnNextAsync(T value) { var sval = _selector(value); if (!_set.Add(sval)) { return(new ValueTask <bool>(true)); } return(_observer.OnNextAsync(value)); }
public static IAsyncObserver <TSource> Materialize <TSource>(IAsyncObserver <Notification <TSource> > observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } return(Create <TSource>( x => observer.OnNextAsync(Notification.CreateOnNext(x)), async ex => { await observer.OnNextAsync(Notification.CreateOnError <TSource>(ex)).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); }, async() => { await observer.OnNextAsync(Notification.CreateOnCompleted <TSource>()).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> Any <TSource>(IAsyncObserver <bool> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } return(Create <TSource>( async x => { await observer.OnNextAsync(true).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(false).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> FirstOrDefault <TSource>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } return(Create <TSource>( async x => { await observer.OnNextAsync(x).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(default(TSource)).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> All <TSource>(IAsyncObserver <bool> observer, Func <TSource, ValueTask <bool> > predicate) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); } return(Create <TSource>( async x => { var b = default(bool); try { b = await predicate(x).ConfigureAwait(false); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } if (!b) { await observer.OnNextAsync(false).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(true).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }
public static IAsyncObserver <TSource> Contains <TSource>(IAsyncObserver <bool> observer, TSource element, IEqualityComparer <TSource> comparer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (comparer == null) { throw new ArgumentNullException(nameof(comparer)); } return(Create <TSource>( async x => { var equals = false; try { equals = comparer.Equals(x, element); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return; } if (equals) { await observer.OnNextAsync(true).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } }, observer.OnErrorAsync, async() => { await observer.OnNextAsync(false).ConfigureAwait(false); await observer.OnCompletedAsync().ConfigureAwait(false); } )); }