public static IAsyncObservable <TSource> Timeout <TSource>(this IAsyncObservable <TSource> source, TimeSpan dueTime, IAsyncObservable <TSource> other)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
return(Create <TSource>(async observer =>
{
var sourceSubscription = new SingleAssignmentAsyncDisposable();
var(sink, disposable) = await AsyncObserver.Timeout(observer, sourceSubscription, dueTime, other).ConfigureAwait(false);
var sourceSubscriptionInner = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
await sourceSubscription.AssignAsync(sourceSubscriptionInner).ConfigureAwait(false);
return disposable;
}));
}
public static ValueTask <IAsyncDisposable> Prepend <TSource>(IAsyncObserver <TSource> observer, IAsyncObservable <TSource> source, IAsyncScheduler scheduler, IEnumerable <TSource> values)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
return(CoreAsync());
async ValueTask <IAsyncDisposable> CoreAsync()
{
var subscription = new SingleAssignmentAsyncDisposable();
var task = await scheduler.ScheduleAsync(async ct =>
{
if (ct.IsCancellationRequested)
{
return;
}
var e = default(IEnumerator <TSource>);
try
{
e = values.GetEnumerator();
}
catch (Exception ex)
{
await observer.OnErrorAsync(ex).RendezVous(scheduler, ct);
return;
}
using (e)
{
while (!ct.IsCancellationRequested)
{
var b = default(bool);
var value = default(TSource);
try
{
b = e.MoveNext();
if (b)
{
value = e.Current;
}
}
catch (Exception ex)
{
await observer.OnErrorAsync(ex).RendezVous(scheduler, ct);
return;
}
if (b)
{
await observer.OnNextAsync(value).RendezVous(scheduler, ct);
}
else
{
break;
}
}
}
if (ct.IsCancellationRequested)
{
return;
}
var inner = await source.SubscribeSafeAsync(observer).ConfigureAwait(false);
await subscription.AssignAsync(inner).RendezVous(scheduler, ct);
}).ConfigureAwait(false);
return(StableCompositeAsyncDisposable.Create(task, subscription));
}
}
public static IAsyncObservable <TSource> DoWhile <TSource>(IAsyncObservable <TSource> source, Func <Task <bool> > condition)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (condition == null)
{
throw new ArgumentNullException(nameof(condition));
}
return(Create <TSource>(async observer =>
{
var subscription = new SerialAsyncDisposable();
var o = default(IAsyncObserver <TSource>);
o = AsyncObserver.CreateUnsafe <TSource>(
observer.OnNextAsync,
observer.OnErrorAsync,
MoveNext
);
async Task Subscribe()
{
var sad = new SingleAssignmentAsyncDisposable();
await subscription.AssignAsync(sad).ConfigureAwait(false);
var d = await source.SubscribeSafeAsync(o).ConfigureAwait(false);
await sad.AssignAsync(d).ConfigureAwait(false);
}
async Task MoveNext()
{
var b = default(bool);
try
{
b = await condition().ConfigureAwait(false);
}
catch (Exception ex)
{
await observer.OnErrorAsync(ex).ConfigureAwait(false);
return;
}
if (b)
{
await Subscribe().ConfigureAwait(false);
}
else
{
await observer.OnCompletedAsync().ConfigureAwait(false);
}
}
await Subscribe().ConfigureAwait(false);
return subscription;
}));
}
