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