private void DoSubscribeTask(bool recovery = false) { _context.TraceSource.StartWith_Subscribing(_context.InstanceId); var subscription = default(ISubscription); try { subscription = Params._source.Subscribe(this); if (recovery) { SubscriptionInitializeVisitor.Subscribe(subscription); SubscriptionInitializeVisitor.SetContext(subscription, _context); } else { SubscriptionInitializeVisitor.Initialize(subscription, _context); } } catch (Exception ex) { subscription?.Dispose(); DoSchedule(new ActionTask(() => { Output.OnError(ex); Dispose(); })); return; } _subscription.Subscription = subscription; }
protected void DoSubscribeTask(bool recovery = false) { EnsureResourceManagement(recovery); if (!recovery) { // Needs to happen before subscribing to the source, so an inner sequence has been emitted // for the observed notifications to flow into. Tick(); } var subscription = Params._source.Subscribe(this); if (recovery) { SubscriptionInitializeVisitor.Subscribe(subscription); SubscriptionInitializeVisitor.SetContext(subscription, Context); } else { SubscriptionInitializeVisitor.Initialize(subscription, Context); } _subscription.Subscription = subscription; }
public void OnNext(ISubscribable <TSource> source) { var id = default(ulong); lock (_lock) { id = unchecked (++_latest); _hasLatest = true; } try { var observer = new i(this, id); var subscription = SubscribeInner <TSource>(source, observer); observer.Subscription = subscription; SubscriptionInitializeVisitor.Subscribe(subscription); SubscriptionInitializeVisitor.SetContext(subscription, _context); _innerSubscription.Subscription = subscription; SubscriptionInitializeVisitor.Start(subscription); } catch (Exception ex) { lock (_lock) { Output.OnError(ex); Dispose(); } } }
public void OnNext(TSource value) { var throttle = default(ISubscribable <TThrottle>); try { throttle = Params._throttleSelector(value); } catch (Exception error) { lock (_gate) { Output.OnError(error); Dispose(); } return; } ulong currentId; lock (_gate) { _hasValue = true; _value = value; _id = unchecked (_id + 1); currentId = _id; } try { #pragma warning disable IDE0079 // Remove unnecessary suppression. #pragma warning disable CA2000 // Dispose objects before losing scope. (Observer will be owned by inner subscription.) var observer = new ThrottleObserver(this, value, currentId); var subscription = SubscribeInner <TThrottle>(throttle, observer); observer.Subscription = subscription; SubscriptionInitializeVisitor.Subscribe(subscription); SubscriptionInitializeVisitor.SetContext(subscription, _context); _cancelable.Subscription = subscription; SubscriptionInitializeVisitor.Start(subscription); #pragma warning restore CA2000 #pragma warning restore IDE0079 } catch (Exception error) { lock (_gate) { Output.OnError(error); Dispose(); } } }
public void Where_DisposeInPredicate() { var invoked = 0; var xs = Scheduler.CreateHotObservable( OnNext(110, 1), OnNext(180, 2), OnNext(230, 3), OnNext(270, 4), OnNext(340, 5), OnNext(380, 6), OnNext(390, 7), OnNext(450, 8), OnNext(470, 9), OnNext(560, 10), OnNext(580, 11), OnCompleted <int>(600), OnNext(610, 12), OnError <int>(620, new Exception()), OnCompleted <int>(630) ); var res = Scheduler.CreateObserver <int>(); var d = default(ISubscription); var ys = default(ISubscribable <int>); Scheduler.ScheduleAbsolute(Created, () => ys = xs.Where(x => { invoked++; if (x == 8) { d.Dispose(); } return(IsPrime(x)); })); Scheduler.ScheduleAbsolute(Subscribed, () => { d = ys.Subscribe(res); SubscriptionInitializeVisitor.Initialize(d, Scheduler.CreateContext()); }); Scheduler.ScheduleAbsolute(Disposed, () => d.Dispose()); Scheduler.Start(); res.Messages.AssertEqual( OnNext(230, 3), OnNext(340, 5), OnNext(390, 7) ); xs.Subscriptions.AssertEqual( Subscribe(200, 450)); Assert.AreEqual(6, invoked); }
public void OnNext(TSource value) { lock (_lock) { if (_innerSubscriptions.Count >= _maxInnerCount) { Output.OnError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The number of concurrent nested sequences produced by the SelectMany operator exceeded {0} items. Please review the SelectMany operator usage to avoid exceeding this limit.", _maxInnerCount))); Dispose(); return; } } ISubscribable <TCollection> collection; try { collection = Params._collectionSelector(value); #pragma warning disable IDE0079 // Remove unnecessary suppression. #pragma warning disable CA2000 // Dispose objects before losing scope. (Observer will be owned by inner subscription.) var observer = new Observer(this, value); var subscription = SubscribeInner <TCollection>(collection, observer); observer.Subscription = subscription; SubscriptionInitializeVisitor.Subscribe(subscription); SubscriptionInitializeVisitor.SetContext(subscription, _context); lock (_lock) { // No need to set dirty flag here, the SubscribeInner call returns // an operator with the dirty flag set to true. _innerSubscriptions.Add(subscription); } SubscriptionInitializeVisitor.Start(subscription); #pragma warning restore CA2000 #pragma warning restore IDE0079 } catch (Exception ex) { lock (_lock) { Output.OnError(ex); Dispose(); return; } } }
public void SelectWithIndex_DisposeInsideSelector() { var xs = Scheduler.CreateHotObservable( OnNext(100, 4), OnNext(200, 3), OnNext(500, 2), OnNext(600, 1) ); var invoked = 0; var res = Scheduler.CreateObserver <int>(); var d = default(ISubscription); d = xs.Select((x, index) => { invoked++; if (Scheduler.Clock > 400) { d.Dispose(); } return(x + index * 10); }).Subscribe(res); SubscriptionInitializeVisitor.Initialize(d, Scheduler.CreateContext()); Scheduler.ScheduleAbsolute(Disposed, d.Dispose); Scheduler.Start(); res.Messages.AssertEqual( OnNext(100, 4), OnNext(200, 13) ); xs.Subscriptions.AssertEqual( Subscribe(0, 500)); Assert.AreEqual(3, invoked); }
public void OnError(Exception error) { if (_retryCount <= 1) { Output.OnError(error); Dispose(); } else { _retryCount--; StateChanged = true; _context.TraceSource.Retry_Retrying_Count(_context.InstanceId, _retryCount, error); var subscription = default(ISubscription); try { subscription = Params._source.Subscribe(this); _subscription.Subscription = subscription; SubscriptionInitializeVisitor.Initialize(subscription, _context); _context.TraceSource.Retry_Retrying(_context.InstanceId, error); } catch (Exception ex) { if (subscription != null) { subscription.Dispose(); } Output.OnError(ex); Dispose(); return; } } }
public void SubscriptionStateVisitor_Basics() { var state = new MockOperatorStateContainer(); var writerFactory = state.CreateWriter(); var readerFactory = state.CreateReader(); var xs = new SimpleSubject <int>(); var o = xs.CreateObserver(); var ys = new Take <int>(xs, 5); { var s1 = ys.Subscribe(Observer.Create <int>(_ => { }, _ => { }, () => { })); var v = new SubscriptionInitializeVisitor(s1); v.Subscribe(); v.Start(); o.OnNext(42); o.OnNext(43); var sv = new SubscriptionStateVisitor(s1); Assert.IsTrue(sv.HasStateChanged()); sv.SaveState(writerFactory); Assert.IsTrue(sv.HasStateChanged()); sv.OnStateSaved(); Assert.IsFalse(sv.HasStateChanged()); o.OnNext(44); o.OnNext(45); Assert.IsTrue(sv.HasStateChanged()); } { var done = false; var s2 = ys.Subscribe(Observer.Create <int>(_ => { }, _ => { }, () => { done = true; })); var sv = new SubscriptionStateVisitor(s2); sv.LoadState(readerFactory); var v = new SubscriptionInitializeVisitor(s2); v.Subscribe(); v.Start(); o.OnNext(46); Assert.IsFalse(done); o.OnNext(47); Assert.IsFalse(done); o.OnNext(48); Assert.IsTrue(done); } }
protected override void StartCore(ISubscription instance, params object[] args) { Debug.Assert(args.Length == 0); SubscriptionInitializeVisitor.Start(instance); }
private void InitializeSubscription(ISubscription subscription) { var visitor = new SubscriptionInitializeVisitor(subscription); visitor.Initialize(_logicalContext); }