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)); }