public void RunAsync_Connectable_Cancel() { SynchronizationContext.SetSynchronizationContext(null); var cts = new CancellationTokenSource(); var scheduler = new TestScheduler(); var s = default(long); var d = default(long); var xs = Observable.Create <int>(observer => { s = scheduler.Clock; return(StableCompositeDisposable.Create( scheduler.ScheduleAbsolute(250, () => { observer.OnNext(42); }), scheduler.ScheduleAbsolute(260, () => { observer.OnCompleted(); }), Disposable.Create(() => { d = scheduler.Clock; }) )); }); var ys = xs.Publish(); var awaiter = default(AsyncSubject <int>); var result = default(int); var t = long.MaxValue; scheduler.ScheduleAbsolute(100, () => awaiter = ys.RunAsync(cts.Token)); scheduler.ScheduleAbsolute(200, () => awaiter.OnCompleted(() => { t = scheduler.Clock; ReactiveAssert.Throws <OperationCanceledException>(() => { result = awaiter.GetResult(); }); })); scheduler.ScheduleAbsolute(210, () => cts.Cancel()); scheduler.Start(); Assert.Equal(100, s); Assert.Equal(210, d); Assert.Equal(210, t); }
public IDisposable Run(TakeUntil <TSource, TOther> parent) { var sourceObserver = new SourceObserver(this); var otherObserver = new OtherObserver(this, sourceObserver); // COMPAT - Order of Subscribe calls per v1.0.10621 var otherSubscription = parent._other.SubscribeSafe(otherObserver); otherObserver.Disposable = otherSubscription; var sourceSubscription = parent._source.SubscribeSafe(sourceObserver); return(StableCompositeDisposable.Create( otherSubscription, sourceSubscription )); }
public IDisposable Run() { isDisposed = false; e = parent.sources.AsSafeEnumerable().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() { 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)); }
public IDisposable Run() { isDisposed = false; isRunNext = false; e = parent.sources.GetEnumerator(); subscription = new SerialDisposable(); IDisposable disposable = Scheduler.DefaultSchedulers.TailRecursion.Schedule(RecursiveRun); return(StableCompositeDisposable.Create(disposable, subscription, Disposable.Create(delegate { lock (gate) { isDisposed = true; e.Dispose(); } }))); }
public IDisposable Run() { base.SetQueue(new ICollection[] { this.q1, this.q2, this.q3, this.q4, this.q5, this.q6, this.q7 }); IDisposable disposable = this.parent.source1.Subscribe(new ZipObserver <T1>(this.gate, this, 0, this.q1)); IDisposable disposable2 = this.parent.source2.Subscribe(new ZipObserver <T2>(this.gate, this, 1, this.q2)); IDisposable disposable3 = this.parent.source3.Subscribe(new ZipObserver <T3>(this.gate, this, 2, this.q3)); IDisposable disposable4 = this.parent.source4.Subscribe(new ZipObserver <T4>(this.gate, this, 3, this.q4)); IDisposable disposable5 = this.parent.source5.Subscribe(new ZipObserver <T5>(this.gate, this, 4, this.q5)); IDisposable disposable6 = this.parent.source6.Subscribe(new ZipObserver <T6>(this.gate, this, 5, this.q6)); IDisposable disposable7 = this.parent.source7.Subscribe(new ZipObserver <T7>(this.gate, this, 6, this.q7)); return(StableCompositeDisposable.Create(new IDisposable[] { disposable, disposable2, disposable3, disposable4, disposable5, disposable6, disposable7, Disposable.Create(delegate { object obj = this.gate; lock (obj) { this.q1.Clear(); this.q2.Clear(); this.q3.Clear(); this.q4.Clear(); this.q5.Clear(); this.q6.Clear(); this.q7.Clear(); } }) })); }
public IDisposable Run() { IDisposable disposable; try { disposable = parent.source.Subscribe(this); } catch { parent.finallyAction(); throw; } return(StableCompositeDisposable.Create(disposable, Disposable.Create(delegate { parent.finallyAction(); }))); }
public IDisposable Run() { _gate = new object(); var fstSubscription = new SingleAssignmentDisposable(); var sndSubscription = new SingleAssignmentDisposable(); var fstO = new F(this, fstSubscription); var sndO = new S(this, sndSubscription); fstO.Other = sndO; sndO.Other = fstO; fstSubscription.Disposable = _parent._first.SubscribeSafe(fstO); sndSubscription.Disposable = _parent._second.SubscribeSafe(sndO); return(StableCompositeDisposable.Create(fstSubscription, sndSubscription)); }
public IDisposable Run() { this.isDisposed = false; this.isRunNext = false; this.e = this.parent.sources.GetEnumerator(); this.subscription = new SerialDisposable(); IDisposable disposable = Scheduler.DefaultSchedulers.TailRecursion.Schedule(new Action <Action>(this.RecursiveRun)); return(StableCompositeDisposable.Create(disposable, this.subscription, Disposable.Create(delegate { object obj = this.gate; lock (obj) { this.isDisposed = true; this.e.Dispose(); } }))); }
public IDisposable Run() { _subscription = new SerialDisposable(); _timer = new SerialDisposable(); var original = new SingleAssignmentDisposable(); _subscription.Disposable = original; _gate = new object(); _id = 0UL; _switched = false; SetTimer(_parent._firstTimeout); original.Disposable = _parent._source.SubscribeSafe(this); return(StableCompositeDisposable.Create(_subscription, _timer)); }
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)); }
public IDisposable Run() { isDisposed = false; IDisposable disposable = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(disposable, Disposable.Create(delegate { lock (scheduleDisposables) { isDisposed = true; foreach (IDisposable scheduleDisposable in scheduleDisposables) { scheduleDisposable.Dispose(); } scheduleDisposables.Clear(); } }))); }
public IDisposable Run(IObservable <TFirst> first, IObservable <TSecond> second) { _gate = new object(); var fstSubscription = new SingleAssignmentDisposable(); var sndSubscription = new SingleAssignmentDisposable(); var fstO = new FirstObserver(this, fstSubscription); var sndO = new SecondObserver(this, sndSubscription); fstO.Other = sndO; sndO.Other = fstO; fstSubscription.Disposable = first.SubscribeSafe(fstO); sndSubscription.Disposable = second.SubscribeSafe(sndO); return(StableCompositeDisposable.Create(fstSubscription, sndSubscription)); }
public IDisposable Run() { _totalTime = TimeSpan.Zero; _nextShift = _parent._timeShift; _nextSpan = _parent._timeSpan; _gate = new object(); _q = new Queue <List <TSource> >(); _timerD = new SerialDisposable(); CreateWindow(); CreateTimer(); var subscription = _parent._source.SubscribeSafe(this); return(StableCompositeDisposable.Create(_timerD, subscription)); }
public IDisposable Run() { this.isDisposed = false; IDisposable disposable = this.parent.source.Subscribe(this); return(StableCompositeDisposable.Create(disposable, Disposable.Create(delegate { object obj = this.actions; lock (obj) { this.isDisposed = true; while (this.actions.Count > 0) { this.actions.First.Value.Dispose(); } } }))); }
public IDisposable Run() { sourceSubscription = new SingleAssignmentDisposable(); sourceSubscription.Disposable = parent.source.Subscribe(this); IDisposable scheduling; var 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)); }
public IDisposable Run() { this.cancelable = new SerialDisposable(); this.active = false; this.running = false; this.queue = new Queue <Timestamped <T> >(); this.onCompleted = false; this.completeAt = default(DateTimeOffset); this.hasFailed = false; this.exception = null; this.ready = true; this.delay = Scheduler.Normalize(this.parent.dueTime); SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable(); this.sourceSubscription = singleAssignmentDisposable; singleAssignmentDisposable.Disposable = this.parent.source.Subscribe(this); return(StableCompositeDisposable.Create(this.sourceSubscription, this.cancelable)); }
private IDisposable ScheduleOnDispatcherNow <TState>(TState state, Func <IScheduler, TState, IDisposable> action) { try { // if _dispatcher is still null (and only then) CompareExchange it with the dispatcher from the first view found if (_dispatcher == null) { var dispatcher = TryGetDispatcher(); Interlocked.CompareExchange(ref _dispatcher, dispatcher, null); } } catch { // Ignore } if (_dispatcher == null || _dispatcher.HasThreadAccess) { return(action(this, state)); } var d = new SingleAssignmentDisposable(); var dispatchResult = _dispatcher.RunAsync( Priority, () => { if (!d.IsDisposed) { try { d.Disposable = action(this, state); } catch (Exception ex) { RaiseUnhandledException(ex); } } }); return(StableCompositeDisposable.Create( d, Disposable.Create(() => dispatchResult.Cancel()))); }
protected override IDisposable SubscribeCore(IObserver <TElement> observer) { if (_refCount != null) { // // [OK] Use of unsafe Subscribe: called on a known subject implementation. // var release = _refCount.GetDisposable(); var subscription = _subject.Subscribe/*Unsafe*/ (observer); return(StableCompositeDisposable.Create(release, subscription)); } else { // // [OK] Use of unsafe Subscribe: called on a known subject implementation. // return(_subject.Subscribe/*Unsafe*/ (observer)); } }
public override IDisposable Run(TParent parent) { _queue = new Queue <System.Reactive.TimeInterval <TSource> >(); _hasCompleted = false; _completeAt = default(TimeSpan); _hasFailed = false; _exception = default(Exception); _watch = _scheduler.StartStopwatch(); RunCore(parent); var sourceSubscription = new SingleAssignmentDisposable(); _sourceSubscription = sourceSubscription; sourceSubscription.Disposable = parent._source.SubscribeSafe(this); return(StableCompositeDisposable.Create(_sourceSubscription, _cancelable)); }
public IDisposable Run() { // // The interactions with OperationStarted/OperationCompleted below allow // for test frameworks to wait until a whole sequence is observed, running // asserts on a per-message level. Also, for ASP.NET pages, the use of the // built-in synchronization context would allow processing to finished in // its entirety before moving on with the page lifecycle. // _parent._context.OperationStarted(); var d = _parent._source.SubscribeSafe(this); var c = Disposable.Create(() => { _parent._context.OperationCompleted(); }); return StableCompositeDisposable.Create(d, c); }
public IDisposable Run() { IDisposable subscription; try { subscription = parent.source.Subscribe(this); } catch { // This behaviour is not same as .NET Official Rx parent.finallyAction(); throw; } return(StableCompositeDisposable.Create(subscription, Disposable.Create(() => { parent.finallyAction(); }))); }
private void EnsureDispatcher() { if (_dispatcherJob == null) { lock (_dispatcherInitGate) { if (_dispatcherJob == null) { _dispatcherJob = _longRunning !.ScheduleLongRunning(Dispatch); // NB: Only reachable when long-running. Disposable.TrySetSerial(ref _disposable, StableCompositeDisposable.Create ( _dispatcherJob, _dispatcherEventRelease )); } } } }
public IDisposable Run() { isDisposed = false; var sourceDisposable = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(sourceDisposable, Disposable.Create(() => { lock (actions) { isDisposed = true; while (actions.Count > 0) { // Dispose will both cancel the action (if not already running) // and remove it from 'actions' actions.First.Value.Dispose(); } } }))); }
public static ManagedReactiveDictionary <TKey, TElement> ToManagedReactiveDictionary <TSource, TKey, TElement>( this IObservable <IEnumerable <TSource> > source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementFactory, Action <TElement> elementDisposer) { var dict = new ReactiveDictionary <TKey, TElement>(); var newDict = new Dictionary <TKey, TSource>(); var keysToRemove = new List <TKey>(); var subscription = source .Subscribe(items => { foreach (var item in items) { newDict.Add(keySelector.Invoke(item), item); } foreach (var kvp in dict) { if (!newDict.ContainsKey(kvp.Key)) { keysToRemove.Add(kvp.Key); } } foreach (var key in keysToRemove) { var element = dict[key]; dict.Remove(key); elementDisposer.Invoke(element); } foreach (var kvp in newDict) { if (!dict.ContainsKey(kvp.Key)) { dict.Add(kvp.Key, elementFactory.Invoke(kvp.Value)); } } newDict.Clear(); keysToRemove.Clear(); }); return(new ManagedReactiveDictionary <TKey, TElement>(dict, StableCompositeDisposable.Create(dict, subscription))); }
private void EnsureDispatcher() { if (_dispatcherJob == null) { lock (_dispatcherInitGate) { if (_dispatcherJob == null) { _dispatcherJob = _longRunning.ScheduleLongRunning(Dispatch); _disposable.Disposable = StableCompositeDisposable.Create ( _dispatcherJob, _dispatcherEventRelease ); } } } }
public virtual AsyncSubject <TSource> RunAsync <TSource>(IConnectableObservable <TSource> source, CancellationToken cancellationToken) { var s = new AsyncSubject <TSource>(); if (cancellationToken.IsCancellationRequested) { return(Cancel(s, cancellationToken)); } var d = source.SubscribeSafe(s); var c = source.Connect(); if (cancellationToken.CanBeCanceled) { RegisterCancelation(s, StableCompositeDisposable.Create(d, c), cancellationToken); } return(s); }
public virtual IObservable <TResult> Create <TResult>(Func <IObserver <TResult>, CancellationToken, Task <Action> > subscribeAsync) { return(new AnonymousObservable <TResult>(observer => { var subscription = new SingleAssignmentDisposable(); var cancellable = new CancellationDisposable(); var taskObservable = subscribeAsync(observer, cancellable.Token).ToObservable(); var taskCompletionObserver = new AnonymousObserver <Action>(a => subscription.Disposable = a != null ? Disposable.Create(a) : Disposable.Empty, observer.OnError, Stubs.Nop); // // We don't cancel the subscription below *ever* and want to make sure the returned resource eventually gets disposed. // Notice because we're using the AnonymousObservable<T> type, we get auto-detach behavior for free. // taskObservable.Subscribe(taskCompletionObserver); return StableCompositeDisposable.Create(cancellable, subscription); })); }
public static IObservable <T> AsObservable <T>(this IAsyncStreamReader <T> stream, bool observeOnMainThread = true, IDisposable streamingResult = null) { var seq = Observable.CreateWithState <T, Tuple <IAsyncStreamReader <T>, IDisposable> >(Tuple.Create(stream, streamingResult), (state, observer) => { var disp = new MultipleAssignmentDisposable(); var b = new AsyncStreamReaderAsObservable_ <T>(disp, state.Item1, observer, state.Item2); b.ConsumeNext(); if (state.Item2 == null) { return(disp); } else { return(StableCompositeDisposable.Create(disp, state.Item2)); } }); return((observeOnMainThread) ? seq.ObserveOnMainThread() : seq); }
public IDisposable Run() { isDisposed = false; var sourceDisposable = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(sourceDisposable, Disposable.Create(() => { lock (scheduleDisposables) { isDisposed = true; foreach (var item in scheduleDisposables) { item.Dispose(); } scheduleDisposables.Clear(); } }))); }