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