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