public IDisposable Run()
{
sourceSubscription = new SingleAssignmentDisposable();
sourceSubscription.Disposable = parent.source.Subscribe(this);
ISchedulerPeriodic schedulerPeriodic = parent.scheduler as ISchedulerPeriodic;
return(StableCompositeDisposable.Create(disposable2: (schedulerPeriodic == null) ? parent.scheduler.Schedule(parent.interval, OnNextRecursive) : schedulerPeriodic.SchedulePeriodic(parent.interval, OnNextTick), disposable1: sourceSubscription));
}
protected override IDisposable SubscribeCore(IObserver <long> observer, IDisposable cancel)
{
Timer timerObserver = new Timer(observer, cancel);
TimeSpan dueTime = (dueTimeA != null)
? dueTimeA.Value - scheduler.Now
: dueTimeB.Value;
// one-shot
if (period == null)
{
return(scheduler.Schedule(Scheduler.Normalize(dueTime), () =>
{
timerObserver.OnNext();
timerObserver.OnCompleted();
}));
}
else
{
ISchedulerPeriodic periodicScheduler = scheduler as ISchedulerPeriodic;
if (periodicScheduler != null)
{
if (dueTime == period.Value)
{
// same(Observable.Interval), run periodic
return(periodicScheduler.SchedulePeriodic(Scheduler.Normalize(dueTime), timerObserver.OnNext));
}
else
{
// Schedule Once + Scheudle Periodic
SerialDisposable disposable = new SerialDisposable();
disposable.Disposable = scheduler.Schedule(Scheduler.Normalize(dueTime), () =>
{
timerObserver.OnNext(); // run first
TimeSpan timeP = Scheduler.Normalize(period.Value);
disposable.Disposable = periodicScheduler.SchedulePeriodic(timeP, timerObserver.OnNext); // run periodic
});
return(disposable);
}
}
else
{
TimeSpan timeP = Scheduler.Normalize(period.Value);
return(scheduler.Schedule(Scheduler.Normalize(dueTime), self =>
{
timerObserver.OnNext();
self(timeP);
}));
}
}
}
public IDisposable Run()
{
this.sourceSubscription = new SingleAssignmentDisposable();
this.sourceSubscription.Disposable = this.parent.source.Subscribe(this);
ISchedulerPeriodic schedulerPeriodic = this.parent.scheduler as ISchedulerPeriodic;
IDisposable disposable;
if (schedulerPeriodic != null)
{
disposable = schedulerPeriodic.SchedulePeriodic(this.parent.interval, new Action(this.OnNextTick));
}
else
{
disposable = this.parent.scheduler.Schedule(this.parent.interval, new Action <Action <TimeSpan> >(this.OnNextRecursive));
}
return(StableCompositeDisposable.Create(this.sourceSubscription, disposable));
}
void CreateTimer()
{
long currentTimerId = timerId;
SingleAssignmentDisposable timerS = new SingleAssignmentDisposable();
timerD.Disposable = timerS; // restart timer(dispose before)
ISchedulerPeriodic periodicScheduler = parent.scheduler as ISchedulerPeriodic;
if (periodicScheduler != null)
{
timerS.Disposable = periodicScheduler.SchedulePeriodic(parent.timeSpan, () => OnNextTick(currentTimerId));
}
else
{
timerS.Disposable = parent.scheduler.Schedule(parent.timeSpan, self => OnNextRecursive(currentTimerId, self));
}
}
public IDisposable Run()
{
sourceSubscription = new SingleAssignmentDisposable();
sourceSubscription.Disposable = parent.source.Subscribe(this);
IDisposable scheduling;
ISchedulerPeriodic periodicScheduler = parent.scheduler as ISchedulerPeriodic;
if (periodicScheduler != null)
{
scheduling = periodicScheduler.SchedulePeriodic(parent.interval, OnNextTick);
}
else
{
scheduling = parent.scheduler.Schedule(parent.interval, OnNextRecursive);
}
return(StableCompositeDisposable.Create(sourceSubscription, scheduling));
}
protected override IDisposable SubscribeCore(UniRx.IObserver <long> observer, IDisposable cancel)
{
Timer timerObserver = new Timer(observer, cancel);
TimeSpan timeSpan = (!dueTimeA.HasValue) ? dueTimeB.Value : (dueTimeA.Value - scheduler.Now);
if (!period.HasValue)
{
return(scheduler.Schedule(Scheduler.Normalize(timeSpan), delegate
{
timerObserver.OnNext();
timerObserver.OnCompleted();
}));
}
ISchedulerPeriodic periodicScheduler = scheduler as ISchedulerPeriodic;
if (periodicScheduler != null)
{
if (timeSpan == period.Value)
{
return(periodicScheduler.SchedulePeriodic(Scheduler.Normalize(timeSpan), timerObserver.OnNext));
}
SerialDisposable disposable = new SerialDisposable();
disposable.Disposable = scheduler.Schedule(Scheduler.Normalize(timeSpan), delegate
{
timerObserver.OnNext();
TimeSpan timeSpan2 = Scheduler.Normalize(period.Value);
disposable.Disposable = periodicScheduler.SchedulePeriodic(timeSpan2, timerObserver.OnNext);
});
return(disposable);
}
TimeSpan timeP = Scheduler.Normalize(period.Value);
return(scheduler.Schedule(Scheduler.Normalize(timeSpan), delegate(Action <TimeSpan> self)
{
timerObserver.OnNext();
self(timeP);
}));
}
private void CreateTimer()
{
long currentTimerId = timerId;
SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable();
timerD.Disposable = singleAssignmentDisposable;
ISchedulerPeriodic schedulerPeriodic = parent.scheduler as ISchedulerPeriodic;
if (schedulerPeriodic != null)
{
singleAssignmentDisposable.Disposable = schedulerPeriodic.SchedulePeriodic(parent.timeSpan, delegate
{
OnNextTick(currentTimerId);
});
}
else
{
singleAssignmentDisposable.Disposable = parent.scheduler.Schedule(parent.timeSpan, delegate(Action <TimeSpan> self)
{
OnNextRecursive(currentTimerId, self);
});
}
}
public CatchSchedulerPeriodic(ISchedulerPeriodic scheduler, Func <TException, bool> handler)
{
_scheduler = scheduler;
_handler = handler;
}
