IEnumerator TakeCoroutine()
{
var wait = new WaitForSeconds(intervalSeconds);
while (!cancelable.IsDisposed)
{
yield return wait;
if (messageQueue.Count > 0 && !hasError)
{
var data = messageQueue.Dequeue();
observer.OnNext(data);
}
if (hasError)
{
if (!cancelable.IsDisposed)
{
cancelable.Dispose();
try { observer.OnError(error); }
finally { Dispose(); }
}
}
else if (calledCompleted && messageQueue.Count <= 0)
{
if (!cancelable.IsDisposed)
{
cancelable.Dispose();
try { observer.OnCompleted(); }
finally { Dispose(); }
}
}
}
}
public override void OnError(Exception error)
{
cancelable.Dispose();
lock (gate) {
try { observer.OnError(error); } finally { Dispose(); }
}
}
public void WhereIndex_DisposeInPredicate()
{
var scheduler = new TestScheduler();
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 = new SerialDisposable();
var ys = default(IObservable <int>);
scheduler.ScheduleAbsolute(Created, () => ys = xs.Where((x, i) =>
{
invoked++;
if (x == 8)
{
d.Dispose();
}
return(IsPrime(x + i * 10));
}));
scheduler.ScheduleAbsolute(Subscribed, () => d.Disposable = ys.Subscribe(res));
scheduler.ScheduleAbsolute(Disposed, () => d.Dispose());
scheduler.Start();
res.Messages.AssertEqual(
OnNext(230, 3),
OnNext(390, 7)
);
xs.Subscriptions.AssertEqual(
Subscribe(200, 450)
);
Assert.AreEqual(6, invoked);
}
public override void OnError(Exception error)
{
cancelable.Dispose();
lock (gate) {
hasValue = false;
id = unchecked (id + 1);
try { observer.OnError(error); } finally { Dispose(); }
}
}
public override void OnError(Exception error)
{
_cancelable.Dispose();
lock (_gate)
{
ForwardOnError(error);
_hasValue = false;
_id = unchecked (_id + 1);
}
}
public void OnError(Exception error)
{
_cancelable.Dispose();
lock (_gate)
{
base._observer.OnError(error);
base.Dispose();
_hasValue = false;
_id = unchecked (_id + 1);
}
}
public static IObservable <T> Create <T>(out NamedPipeClientStream stream,
string server,
string pipeName,
EventHandler onConnected = null)
{
stream = new NamedPipeClientStream(server, pipeName, PipeDirection.InOut,
PipeOptions.Asynchronous);
var clientStream = stream;
return(Observable.Using(() => clientStream, resource => Observable.Create <T>(o =>
{
var currentStateSubscription = new SerialDisposable();
return NewThreadScheduler.Default.Schedule(
new FormatterIterator <T>(resource, new BinaryFormatter(), onConnected), (state, self) =>
{
var observable = state.ReadNext();
if (observable != null)
{
currentStateSubscription.Disposable =
observable.Subscribe(
str =>
{
self(state);
o.OnNext(str);
},
ex =>
{
currentStateSubscription
.Dispose();
o.OnError(ex);
resource.Close();
},
() =>
{
currentStateSubscription
.Dispose();
o.OnCompleted();
resource.Close();
});
}
else
{
o.OnError(new Exception("Scheduling aborted."));
}
}
);
})));
}
public void Dispose()
{
IsRunning = false;
_scheduledFrame.Dispose();
_watch.Reset();
}
public TraderWindowModel(IObjectProvider objectProvider, TraderWindowFactory traderWindowFactory)
{
_objectProvider = objectProvider;
_interTabClient = new InterTabClient(traderWindowFactory);
_showMenu = new Command(OnShowMenu);
var menuController = _data.AsObservable(vc => vc.Id)
.Filter(vc => vc.Content is MenuItems)
.Transform(vc => (MenuItems)vc.Content)
.MergeMany(menuItem => menuItem.ItemCreated)
.Subscribe(item =>
{
_data.Add(item);
Selected = item;
});
_cleanUp = Disposable.Create(() =>
{
menuController.Dispose();
foreach (var disposable in _data.Select(vc => vc.Content).OfType <IDisposable>())
{
disposable.Dispose();
}
_newMenuItemSubscriber.Dispose();
});
}
protected override void OnDetaching()
{
this.setResolvedSource(null);
base.OnDetaching();
watcher.Dispose();
}
public void Dispose()
{
reconnectDisposable?.Dispose();
Logger.Swallow(tags.OnCompleted);
tags?.Dispose();
proto?.Dispose();
}
public void SerialDisposable_Test()
{
// arrange
var d1 = new BooleanDisposable();
var d2 = new BooleanDisposable();
var d3 = new BooleanDisposable();
var disp = new SerialDisposable();
disp.Disposable = d1;
// act & verify
Assert.IsFalse(d1.IsDisposed);
Assert.IsFalse(d2.IsDisposed);
Assert.IsFalse(d3.IsDisposed);
Assert.IsFalse(disp.IsDisposed);
disp.Disposable = d2;
Assert.IsTrue(d1.IsDisposed);
Assert.IsFalse(d2.IsDisposed);
Assert.IsFalse(d3.IsDisposed);
Assert.IsFalse(disp.IsDisposed);
disp.Dispose();
Assert.IsTrue(d1.IsDisposed);
Assert.IsTrue(d2.IsDisposed);
Assert.IsFalse(d3.IsDisposed);
Assert.IsTrue(disp.IsDisposed);
disp.Disposable = d3;
Assert.IsTrue(d1.IsDisposed);
Assert.IsTrue(d2.IsDisposed);
Assert.IsTrue(d3.IsDisposed);
Assert.IsTrue(disp.IsDisposed);
}
public void Stop()
{
_log.Log("Stopping SomeWindowsService");
_quartzScheduler?.Shutdown();
_configWatcherDisposable.Dispose();
_observableFileSystemWatcher.Dispose();
}
public void is_disposed_returns_true_if_underlying_serial_disposable_is_disposed()
{
var sut = new SerialDisposable <IDisposable>();
sut.Dispose();
Assert.True(sut.IsDisposed);
}
public override void Dispose()
{
logger.Info("Disposing");
pollerDisposable.Dispose();
tagStreamListener?.Dispose();
base.Dispose();
}
/// <inheritdoc />
public IDisposable BindInteraction <TViewModel, TView, TInput, TOutput, TDontCare>(
TViewModel?viewModel,
TView view,
Expression <Func <TViewModel, Interaction <TInput, TOutput> > > propertyName,
Func <InteractionContext <TInput, TOutput>, IObservable <TDontCare> > handler)
where TViewModel : class
where TView : class, IViewFor
{
if (propertyName is null)
{
throw new ArgumentNullException(nameof(propertyName));
}
if (handler is null)
{
throw new ArgumentNullException(nameof(handler));
}
var vmExpression = Reflection.Rewrite(propertyName.Body);
var source = Reflection.ViewModelWhenAnyValue(viewModel, view, vmExpression).Cast <Interaction <TInput, TOutput> >();
var interactionDisposable = new SerialDisposable();
return(source
.Where(x => x is not null)
.Do(x => interactionDisposable.Disposable = x.RegisterHandler(handler))
.Finally(() => interactionDisposable.Dispose())
.Subscribe(_ => { }, ex => this.Log().Error(ex, $"{vmExpression} Interaction Binding received an Exception!")));
}
public IDisposable Run()
{
isFirstSubscribe = true;
isDisposed = false;
isStopped = false;
e = parent.sources.GetEnumerator();
subscription = new SerialDisposable();
schedule = new SingleAssignmentDisposable();
UniRx.IObservable <Unit> trigger = parent.trigger;
Action <Unit> onNext = delegate
{
lock (gate)
{
isStopped = true;
e.Dispose();
subscription.Dispose();
schedule.Dispose();
base.observer.OnCompleted();
}
};
UniRx.IObserver <T> observer = base.observer;
stopper = trigger.Subscribe(onNext, observer.OnError);
schedule.Disposable = Scheduler.CurrentThread.Schedule(RecursiveRun);
return(new CompositeDisposable(schedule, subscription, stopper, Disposable.Create(delegate
{
lock (gate)
{
isDisposed = true;
e.Dispose();
}
})));
}
protected override void Dispose(bool disposing)
{
Click -= PriceButton_Click;
_propertyChangedSubscription.Dispose();
_executingSubscription.Dispose();
_canExecuteSubscription.Dispose();
}
protected override void OnUnloaded()
{
base.OnUnloaded();
_subscriptions.Dispose();
#endif
}
public static IObservable <string> Create(out NamedPipeServerStream stream, string pipeName)
{
stream = new NamedPipeServerStream(pipeName, PipeDirection.InOut,
1, PipeTransmissionMode.Byte,
PipeOptions.Asynchronous);
stream.WaitForConnection();
var serverStream = stream;
return(Observable.Create <string>(o =>
{
var currentStateSubscription = new SerialDisposable();
return NewThreadScheduler.Default.Schedule(
new StringIterator(serverStream), (state, self) =>
currentStateSubscription.Disposable = state.ReadNext()
.Subscribe(str =>
{
self(state);
o.OnNext(str);
},
o.OnError,
() =>
{
currentStateSubscription.Dispose();
o.OnCompleted();
})
);
}));
}
public static IObservable <T> Create <T>(out NamedPipeClientStream stream,
string server,
string pipeName,
IFormatter formatter)
{
stream = new NamedPipeClientStream(server, pipeName, PipeDirection.InOut,
PipeOptions.Asynchronous);
stream.Connect();
var serverStream = stream;
return(Observable.Create <T>(o =>
{
var currentStateSubscription = new SerialDisposable();
return NewThreadScheduler.Default.Schedule(
new FormatterIterator <T>(serverStream, formatter), (state, self) =>
currentStateSubscription.Disposable = state.ReadNext()
.Subscribe(str =>
{
self(state);
o.OnNext(str);
},
o.OnError,
() =>
{
currentStateSubscription.Dispose();
o.OnCompleted();
})
);
}));
}
public void Return_DisposedAfterNext()
{
var scheduler = new TestScheduler();
var d = new SerialDisposable();
var xs = Observable.Return(42, scheduler);
var res = scheduler.CreateObserver <int>();
scheduler.ScheduleAbsolute(100, () =>
d.Disposable = xs.Subscribe(
x =>
{
d.Dispose();
res.OnNext(x);
},
res.OnError,
res.OnCompleted
)
);
scheduler.Start();
res.Messages.AssertEqual(
OnNext(101, 42)
);
}
public IDisposable Run()
{
isFirstSubscribe = true;
isDisposed = false;
isStopped = false;
e = parent.sources.GetEnumerator();
subscription = new SerialDisposable();
schedule = new SingleAssignmentDisposable();
stopper = parent.trigger.Subscribe(_ =>
{
lock (gate)
{
isStopped = true;
e.Dispose();
subscription.Dispose();
schedule.Dispose();
observer.OnCompleted();
}
}, observer.OnError);
schedule.Disposable = Scheduler.CurrentThread.Schedule(RecursiveRun);
return(new CompositeDisposable(schedule, subscription, stopper, Disposable.Create(() =>
{
lock (gate)
{
isDisposed = true;
e.Dispose();
}
})));
}
public void Dispose()
{
if (!_disposed)
{
_priceSubscription.Dispose();
_disposed = true;
}
}
public void AssignMultipleTimes()
{
int i = 0, j = 0, k = 0;
var d = new SerialDisposable();
d.Disposable = Disposable.Create(() => i++);
d.Disposable = Disposable.Create(() => j++);
Assert.AreEqual(1, i, "#1");
d.Dispose();
d.Disposable = Disposable.Create(() => k++); // immediately disposed
Assert.AreEqual(1, j, "#2");
Assert.AreEqual(1, k, "#3");
d.Dispose(); // invoke once more
Assert.AreEqual(1, i, "#4");
Assert.AreEqual(1, j, "#5");
Assert.AreEqual(1, k, "#6");
}
public KeyboardNavigationHandler()
{
_cleanUp = Disposable.Create(() =>
{
_keySubscriber.Dispose();
_keyStream.OnCompleted();
});
}
public bool DisconnectDevice()
{
_recorder.Close();
_subscription?.Dispose();
return(true);
}
public override void OnError(Exception error)
{
bool timeout;
lock (gate)
{
timeout = isTimeout;
objectId++;
}
if (timeout)
{
return;
}
timerSubscription.Dispose();
try { observer.OnError(error); } finally { Dispose(); }
}
public ModalDialogContext(string title = null)
{
var activeView = new SerialDisposable();
ModalDialogView dialog = null; // new ModalDialogView();
var dispatcher = Application.Current.Dispatcher;
//var dispatcher = dialog.Dispatcher;
dispatcher.BeginInvoke(() => {
dialog = new ModalDialogView();
if (!disposables.IsDisposed)
{
disposables.Add(
Disposable.Create(
() => dispatcher.BeginInvoke(
() => dialog.Close()
)
)
);
dialog.Header = title;
dialog.Owner = Application.Current.MainWindow;
dialog.WindowStartupLocation = WindowStartupLocation.CenterOwner;
dialog.SizeToContent = SizeToContent.WidthAndHeight;
dialog.ShowInTaskbar = false;
dialog.ShowDialog();
activeView.Dispose();
}
});
var presenter = ViewPresenter.Create(view => {
var disp = new CompositeDisposable();
activeView.Disposable = disp;
dispatcher.BeginInvoke(() => {
dbg.Assert(dialog != null);
if (!disp.IsDisposed)
{
dbg.Assert(dialog.Content == null);
dialog.Content = view;
var header = NavigationContext.GetTitle(view);
dialog.Header = header ?? title;
disp.Add(Disposable.Create(() => {
dispatcher.BeginInvoke(() => {
dbg.Assert(dialog.Content == view);
dialog.Header = title;
dialog.Content = null;
var d = view as IDisposable;
if (d != null)
{
d.Dispose();
}
});
}));
}
});
return(disp);
});
container.RegisterInstance <IViewPresenter>(presenter);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
_disposable.Dispose();
}
}
public void Serial()
{
var d = new SerialDisposable();
d.IsDisposed.IsFalse();
var id1 = new IdDisp(1);
var id2 = new IdDisp(2);
var id3 = new IdDisp(3);
// dispose first
d.Dispose();
d.IsDisposed.IsTrue();
d.Disposable = id1; id1.IsDisposed.IsTrue();
d.Disposable = id2; id2.IsDisposed.IsTrue();
d.Disposable = id3; id3.IsDisposed.IsTrue();
// normal flow
d = new SerialDisposable();
id1 = new IdDisp(1);
id2 = new IdDisp(2);
id3 = new IdDisp(3);
d.Disposable = id1; id1.IsDisposed.IsFalse();
d.Dispose();
id1.IsDisposed.IsTrue();
d.Disposable = id2; id2.IsDisposed.IsTrue();
d.Disposable = id3; id3.IsDisposed.IsTrue();
// exception flow
d = new SerialDisposable();
id1 = new IdDisp(1);
id2 = new IdDisp(2);
id3 = new IdDisp(3);
d.Disposable = id1;
id1.IsDisposed.IsFalse();
d.Disposable = id2;
id1.IsDisposed.IsTrue();
id2.IsDisposed.IsFalse();
d.Disposable = id3;
id2.IsDisposed.IsTrue();
id3.IsDisposed.IsFalse();
d.Dispose();
id3.IsDisposed.IsTrue();
// null
d = new SerialDisposable();
id1 = new IdDisp(1);
d.Disposable = null;
d.Dispose();
d.Disposable = null;
}
