public IDisposable Run()
{
sourceSubscription = new SingleAssignmentDisposable();
timerSubscription = new SerialDisposable();
timerSubscription.Disposable = RunTimer(objectId);
sourceSubscription.Disposable = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(timerSubscription, sourceSubscription));
}
public IDisposable Run()
{
tick = new ThrottleFirstFrameTick(this);
cancelable = new SerialDisposable();
var subscription = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(cancelable, subscription));
}
protected override IDisposable SubscribeCore(IObserver <long> observer, IDisposable cancel)
{
var timerObserver = new Timer(observer, cancel);
var 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
{
var 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
var disposable = new SerialDisposable();
disposable.Disposable = scheduler.Schedule(Scheduler.Normalize(dueTime), () =>
{
timerObserver.OnNext(); // run first
var timeP = Scheduler.Normalize(period.Value);
disposable.Disposable = periodicScheduler.SchedulePeriodic(timeP, timerObserver.OnNext); // run periodic
});
return(disposable);
}
}
else
{
var timeP = Scheduler.Normalize(period.Value);
return(scheduler.Schedule(Scheduler.Normalize(dueTime), self =>
{
timerObserver.OnNext();
self(timeP);
}));
}
}
}
public IDisposable Run()
{
list = new List <T>();
timerId = 0L;
timerD = new SerialDisposable();
CreateTimer();
var subscription = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(subscription, timerD));
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var m = new SingleAssignmentDisposable();
var d = new SerialDisposable();
d.Disposable = m;
m.Disposable = scheduler.Schedule(() =>
{
d.Disposable = new ScheduledDisposable(scheduler, source.Subscribe(observer));
});
return(d);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var m = new SingleAssignmentDisposable();
var d = new SerialDisposable();
d.Disposable = m;
m.Disposable = subscribeTrigger.SubscribeWithState3(observer, d, source, (_, o, disp, s) =>
{
disp.Disposable = s.Subscribe(o);
});
return(d);
}
public IDisposable Run()
{
totalTime = TimeSpan.Zero;
nextShift = parent.timeShift;
nextSpan = parent.timeSpan;
q = new Queue <IList <T> >();
timerD = new SerialDisposable();
q.Enqueue(new List <T>());
CreateTimer();
var subscription = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(subscription, timerD));
}
public IDisposable Run()
{
isDisposed = false;
e = parent.sources.GetEnumerator();
subscription = new SerialDisposable();
var schedule = Scheduler.DefaultSchedulers.TailRecursion.Schedule(RecursiveRun);
return(StableCompositeDisposable.Create(schedule, subscription, Disposable.Create(() =>
{
lock (gate)
{
this.isDisposed = true;
this.e.Dispose();
}
})));
}
public IDisposable Run()
{
cancelable = new SerialDisposable();
active = false;
running = false;
queue = new Queue <Timestamped <T> >();
onCompleted = false;
completeAt = default(DateTimeOffset);
hasFailed = false;
exception = default(Exception);
ready = true;
delay = Scheduler.Normalize(parent.dueTime);
var _sourceSubscription = new SingleAssignmentDisposable();
sourceSubscription = _sourceSubscription; // assign to field
_sourceSubscription.Disposable = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(sourceSubscription, cancelable));
}
