public static async ValueTask Delay(this IAsyncScheduler scheduler, TimeSpan dueTime, CancellationToken token = default)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
var tcs = new TaskCompletionSource <bool>();
var task = await scheduler.ScheduleAsync(ct =>
{
if (ct.IsCancellationRequested)
{
tcs.TrySetCanceled(ct);
}
else
{
tcs.SetResult(true);
}
return(Task.CompletedTask);
}, dueTime);
using (token.Register(() => task.DisposeAsync()))
{
await tcs.Task;
}
}
public TaskAwaitable(Task task, bool continueOnCapturedContext, IAsyncScheduler scheduler, CancellationToken token)
{
_task = task;
_continueOnCapturedContext = continueOnCapturedContext;
_scheduler = scheduler;
_token = token;
}
public ReplayTime(bool concurrent, IAsyncScheduler scheduler, int bufferSize, TimeSpan window, Func <IAsyncObserver <T>, IScheduledAsyncObserver <T> > createObserver)
: base(concurrent, createObserver)
{
_scheduler = scheduler;
_bufferSize = bufferSize;
_window = window;
}
public Observer(IAsyncObserver <T> observer, TimeSpan time, IAsyncScheduler scheduler)
: base(observer)
{
_cts = new CancellationTokenSource();
_time = time;
_scheduler = scheduler;
}
public static IAwaitable RendezVous(this IAsyncScheduler scheduler)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(new RendezVousAwaitable(scheduler, CancellationToken.None));
}
public static ValueTaskAwaitable <T> RendezVous <T>(this ValueTask <T> task, IAsyncScheduler scheduler, CancellationToken token = default)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(new ValueTaskAwaitable <T>(task, continueOnCapturedContext: false, scheduler, token));
}
public static IAsyncObservable <TSource> Empty <TSource>(IAsyncScheduler scheduler)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <TSource>(observer => AsyncObserver.Empty(observer, scheduler)));
}
public static IAsyncObservable <TSource> Repeat <TSource>(TSource value, IAsyncScheduler scheduler)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <TSource>(observer => AsyncObserver.Repeat(observer, value, scheduler)));
}
public static IAwaitable <T> RendezVous <T>(this ValueTask <T> task, IAsyncScheduler scheduler, CancellationToken token)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(new ValueTaskAwaitable <T>(task, false, scheduler, token));
}
public static IAsyncObservable <int> ProduceSlowly(this IAsyncScheduler scheduler, params TimeSpan[] delays)
{
return(AsyncObservable.Range(0, delays.Length)
.Select(async(i, ca) =>
{
await scheduler.Delay(delays[i], ca).ConfigureAwait(false);
return i;
}));
}
public static IAsyncObservable <long> Timer(DateTimeOffset dueTime, IAsyncScheduler scheduler)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <long>(observer => AsyncObserver.Timer(observer, dueTime, scheduler)));
}
public TaskAwaitable(Task task, bool continueOnCapturedContext, IAsyncScheduler scheduler, CancellationToken token)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
_task = task.ConfigureAwait(continueOnCapturedContext).GetAwaiter();
_scheduler = scheduler;
_token = token;
}
public static IAwaitable RendezVous(this IAsyncScheduler scheduler, CancellationToken token)
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
token.ThrowIfCancellationRequested();
return(new RendezVousAwaitable(scheduler, token));
}
public static IAwaitable RendezVous(this Task task, IAsyncScheduler scheduler, CancellationToken token)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(new TaskAwaitable(task, false, scheduler, token));
}
public static IAsyncObservable <Unit> ToAsyncObservable(this Task task, IAsyncScheduler scheduler)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(AsyncObservable.Create <Unit>(observer => task.AcceptAsync(observer, scheduler)));
}
public static IAsyncObservable <long> Interval(TimeSpan period, IAsyncScheduler scheduler)
{
if (period < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(period));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <long>(observer => AsyncObserver.Interval(observer, period, scheduler)));
}
public ReplayAsyncSubject(bool concurrent, TimeSpan window, IAsyncScheduler scheduler)
{
if (window < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(window));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
_impl = new ReplayTime(concurrent, scheduler, int.MaxValue, window, o => CreateScheduledObserver(o, scheduler));
}
public static IAsyncObservable <Unit> Start(Action action, IAsyncScheduler scheduler)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(ToAsync(action, scheduler)());
}
public static TaskAwaitable RendezVous(this Task task, IAsyncScheduler scheduler, CancellationToken token = default)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(new TaskAwaitable(task, continueOnCapturedContext: false, scheduler, token));
}
public static IAsyncObservable <TSource> Throw <TSource>(Exception error, IAsyncScheduler scheduler)
{
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <TSource>(observer => AsyncObserver.Throw(observer, error, scheduler)));
}
public static IAsyncObservable <Unit> FromAsync(Func <Task> actionAsync, IAsyncScheduler scheduler)
{
if (actionAsync == null)
{
throw new ArgumentNullException(nameof(actionAsync));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Defer(() => StartAsync(actionAsync, scheduler)));
}
public static IAsyncObservable <int> Range(int start, int count, IAsyncScheduler scheduler)
{
if (count < 0 || ((long)start) + count - 1 > int.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
return(Create <int>(observer => AsyncObserver.Range(observer, start, count, scheduler)));
}
//make use of current timespan scheduling
//but with UTC and add hour on ambiguous when time < now
public AsyncCronScheduler(IAsyncScheduler scheduler, Func <Task> action, string cron)
{
_scheduler = scheduler;
_action = async() =>
{
await action();
await ScheduleNextAsync();
};
//parse cron
//find next and schedule
//on next, repeat
//TODO: try parse without and then with seconds
_cronExpression = new CronExpression(cron);
_ = ScheduleNextAsync();
}
public static async ValueTask <TResult> ExecuteAsync <TResult>(this IAsyncScheduler scheduler, Func <CancellationToken, ValueTask <TResult> > action, CancellationToken token = default)
{
var tcs = new TaskCompletionSource <TResult>();
var d = await scheduler.ScheduleAsync(async ct =>
{
var res = default(TResult);
try
{
ct.ThrowIfCancellationRequested();
res = await action(ct).RendezVous(scheduler, ct);
}
catch (OperationCanceledException ex) when(ex.CancellationToken == ct)
{
tcs.TrySetCanceled(ct);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
finally
{
tcs.TrySetResult(res);
}
});
using (token.Register(() =>
{
try
{
d.DisposeAsync();
}
finally
{
tcs.TrySetCanceled(token);
}
}))
{
return(await tcs.Task.ConfigureAwait(false));
}
}
public static IAsyncObservable <Unit> StartAsync(Func <Task> actionAsync, IAsyncScheduler scheduler)
{
if (actionAsync == null)
{
throw new ArgumentNullException(nameof(actionAsync));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
var task = default(Task);
try
{
task = actionAsync();
}
catch (Exception ex)
{
return(Throw <Unit>(ex));
}
return(task.ToAsyncObservable(scheduler));
}
public ReplayAsyncSubject(bool concurrent, int bufferSize, IAsyncScheduler scheduler)
{
if (bufferSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferSize));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (bufferSize == 1)
{
_impl = new ReplayOne(concurrent, o => CreateScheduledObserver(o, scheduler));
}
else if (bufferSize == int.MaxValue)
{
_impl = new ReplayAll(concurrent, o => CreateScheduledObserver(o, scheduler));
}
else
{
_impl = new ReplayMany(concurrent, o => CreateScheduledObserver(o, scheduler), bufferSize);
}
}
public SchedulerService(IAsyncScheduler scheduler)
{
this.scheduler = scheduler;
}
public static IAsyncObservable <TSource> Append <TSource>(this IAsyncObservable <TSource> source, IAsyncScheduler scheduler, params TSource[] values)
{
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(Create <TSource>(async observer =>
{
var d = new CompositeAsyncDisposable();
var(sink, disposable) = AsyncObserver.Append(observer, scheduler, values);
await d.AddAsync(disposable).ConfigureAwait(false);
var subscription = await source.SubscribeSafeAsync(sink).ConfigureAwait(false);
await d.AddAsync(subscription).ConfigureAwait(false);
return d;
}));
}
public static IAsyncObservable <TSource> SkipUntil <TSource>(this IAsyncObservable <TSource> source, DateTimeOffset endTime, IAsyncScheduler scheduler)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
// REVIEW: May be easier to just use SkipUntil with a Timer parameter. Do we want SkipUntil on the observer?
return(Create <TSource>(async observer =>
{
var(sourceObserver, timer) = await AsyncObserver.SkipUntil(observer, endTime).ConfigureAwait(false);
var subscription = await source.SubscribeSafeAsync(sourceObserver).ConfigureAwait(false);
return StableCompositeAsyncDisposable.Create(subscription, timer);
}));
}
public static IAsyncObservable <TSource> StartAsync <TSource>(Func <CancellationToken, Task <TSource> > functionAsync, IAsyncScheduler scheduler)
{
if (functionAsync == null)
{
throw new ArgumentNullException(nameof(functionAsync));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
var cancel = new CancellationAsyncDisposable();
var task = default(Task <TSource>);
try
{
task = functionAsync(cancel.Token);
}
catch (Exception ex)
{
return(Throw <TSource>(ex));
}
return(Create <TSource>(async observer =>
{
var subscription = await task.ToAsyncObservable(scheduler).SubscribeAsync(observer).ConfigureAwait(false);
return StableCompositeAsyncDisposable.Create(cancel, subscription);
}));
}
