public IDisposable SchedulePeriodically(Action action, TimeSpan initialDelay, TimeSpan period)
{
MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable outer = new MultipleAssignmentDisposable(inner);
if (tasks.Add(outer))
{
IDisposable cancel = new ActionWeakDisposable(() => tasks.Remove(outer));
long startTime = NowUtc() + (long)initialDelay.TotalMilliseconds;
long periodMillis = (long)period.TotalMilliseconds;
long[] count = new long[1];
Action nextAction = null;
nextAction = () =>
{
if (!outer.IsDisposed())
{
action();
long now = NowUtc();
long c = ++count[0];
long next = startTime + c * periodMillis;
long toDelay = Math.Max(0, next - startTime);
outer.Set(Schedule(nextAction, TimeSpan.FromMilliseconds(toDelay)));
}
};
IDisposable f = Task.Delay(initialDelay).ContinueWith(a =>
{
if (!outer.IsDisposed())
{
outer.Set(Schedule(nextAction));
}
});
inner.Set(f);
return(cancel);
}
return(EmptyDisposable.Instance);
}
public static ICompletable ToCompletable(this Task task)
{
return(Create(cs =>
{
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable();
cs.OnSubscribe(mad);
IDisposable d = task.ContinueWith(t =>
{
Exception e = t.Exception;
if (e == null)
{
cs.OnComplete();
}
else
{
cs.OnError(e);
}
});
mad.Set(d);
}));
}
public static ISingle <long> Timer(TimeSpan delay, IScheduler scheduler)
{
return(Create <long>(s =>
{
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable();
s.OnSubscribe(mad);
mad.Set(scheduler.ScheduleDirect(() => s.OnSuccess(0), delay));
}));
}
public static ICompletable Timer(TimeSpan time, IScheduler scheduler)
{
return(Create(cs =>
{
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable();
cs.OnSubscribe(mad);
if (!mad.IsDisposed())
{
mad.Set(scheduler.ScheduleDirect(() => cs.OnComplete()));
}
}));
}
public static ISingle <T> SubscribeOn <T>(this ISingle <T> source, IScheduler scheduler)
{
return(Create <T>(s =>
{
MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(inner);
inner.Set(scheduler.ScheduleDirect(() =>
{
source.Subscribe(new SingleSubscriberWrapper <T>(s, mad));
}));
}));
}
public static ICompletable DelaySubscription(this ICompletable source, TimeSpan delay, IScheduler scheduler)
{
return(Create(cs =>
{
MultipleAssignmentDisposable t = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(t);
cs.OnSubscribe(mad);
t.Set(scheduler.ScheduleDirect(() => {
source.Subscribe(new SubscribeOnCompletableSubscriber(cs, mad));
}, delay));
}));
}
public static ISingle <T> DelaySubscription <T>(this ISingle <T> source, TimeSpan delay, IScheduler scheduler)
{
return(Create <T>(s =>
{
MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(inner);
s.OnSubscribe(mad);
inner.Set(scheduler.ScheduleDirect(() => {
source.Subscribe(new SingleSubscriberWrapper <T>(s, mad));
}, delay));
}));
}
public static ICompletable SubscribeOn(this ICompletable source, IScheduler scheduler)
{
return(Create(cs =>
{
MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable outer = new MultipleAssignmentDisposable(inner);
cs.OnSubscribe(outer);
inner.Set(scheduler.ScheduleDirect(() =>
{
source.Subscribe(new SubscribeOnCompletableSubscriber(cs, outer));
}));
}));
}
public static ISingle <T> ToSingle <T>(this Task <T> task)
{
return(Create <T>(s =>
{
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable();
s.OnSubscribe(mad);
mad.Set(task.ContinueWith(t =>
{
Exception e = t.Exception;
if (e != null)
{
s.OnError(e);
}
else
{
s.OnSuccess(t.Result);
}
}));
}));
}
public IDisposable Schedule(Action action, TimeSpan delay)
{
MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable outer = new MultipleAssignmentDisposable(inner);
if (tasks.Add(outer))
{
IDisposable cancel = new ActionWeakDisposable(() => tasks.Remove(outer));
IDisposable f = Task.Delay(delay).ContinueWith(a =>
{
if (!outer.IsDisposed())
{
outer.Set(Schedule(action));
}
});
inner.Set(f);
return(cancel);
}
return(EmptyDisposable.Instance);
}
public override IDisposable Schedule(IRunnable action, TimeSpan delay)
{
MultipleAssignmentDisposable first = new MultipleAssignmentDisposable();
MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(first);
IDisposable d = Task.Delay(delay).ContinueWith(t => {
IDisposable d1 = Schedule(action);
mad.Set(d1);
});
first.Set(d);
return mad;
}
public void OnSubscribe(IDisposable d)
{
mad.Set(d);
}