private static IObservable <Unit> CalmingWindows <T>(IObservable <T> observable, TimeSpan calmingPeriod, IScheduler scheduler) => Observable.Create <Unit>(observer => { var calmingTimer = new MultipleAssignmentDisposable(); var calmingWindows = new Subject <Unit>(); var calmerSubscription = observable.Subscribe( onNext: next => { calmingTimer.Disposable?.Dispose(); calmingTimer.Disposable = scheduler.Schedule( calmingPeriod, () => calmingWindows.OnNext(Unit.Default)); }, onError: exception => { calmingTimer.Dispose(); calmingWindows.OnError(exception); }, onCompleted: () => { calmingTimer.Dispose(); calmingWindows.OnCompleted(); }); return(new CompositeDisposable { calmingTimer, calmerSubscription, calmingWindows.Subscribe(observer), calmingWindows }); });
public void MultipleAssignmentDisposable() { var m = new MultipleAssignmentDisposable(); var disp1 = false; var d1 = Disposable.Create(() => { disp1 = true; }); m.Disposable = d1; Assert.Same(d1, m.Disposable); Assert.False(m.IsDisposed); var disp2 = false; var d2 = Disposable.Create(() => { disp2 = true; }); m.Disposable = d2; Assert.Same(d2, m.Disposable); Assert.False(m.IsDisposed); Assert.False(disp1); m.Dispose(); Assert.True(disp2); Assert.True(m.IsDisposed); //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal. m.Disposable.Dispose(); // This should be a nop. var disp3 = false; var d3 = Disposable.Create(() => { disp3 = true; }); m.Disposable = d3; Assert.True(disp3); //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal. m.Disposable.Dispose(); // This should be a nop. Assert.True(m.IsDisposed); }
public void AssignMultipleTimes() { int i = 0, j = 0, k = 0; var d = new MultipleAssignmentDisposable(); d.Disposable = Disposable.Create(() => i++); d.Disposable = Disposable.Create(() => j++); d.Dispose(); d.Disposable = Disposable.Create(() => k++); // immediately disposed Assert.AreEqual(0, i, "#1"); Assert.AreEqual(1, j, "#2"); Assert.AreEqual(1, k, "#3"); d.Dispose(); // invoke once more Assert.AreEqual(1, j, "#4"); Assert.AreEqual(1, k, "#5"); }
public static Func <Action <TResult>, Action <Exception>, IBackgroundTask> CreateForAsync <TResult>(FSharpAsync <TResult> async, DeviceDescriptionHolder dev) { return((onSuccess, onError) => { var disp = new MultipleAssignmentDisposable(); var backgroundTask = new AnonymousBackgroundTask(); backgroundTask.name = "Restore device " + dev.Name; backgroundTask.description = "Address: " + dev.Address; backgroundTask.state = BackgroundTaskState.InProgress; backgroundTask.disposable = Disposable.Create(() => { disp.Dispose(); backgroundTask.state = BackgroundTaskState.Canceled; }); disp.Disposable = async.Subscribe( res => { onSuccess(res); backgroundTask.state = BackgroundTaskState.Completed; }, err => { onError(err); backgroundTask.state = BackgroundTaskState.Failed; } ); return backgroundTask; }); }
public void SettingDisposableAfterDisposeCausesItToBeDisposed() { var subject = new MultipleAssignmentDisposable(); subject.Dispose(); var disposed = false; subject.Disposable = Disposable.Create(() => disposed = true); Assert.IsTrue(disposed); }
public void AssignNull() { int i = 0; var d = new MultipleAssignmentDisposable(); d.Disposable = Disposable.Create(() => i++); d.Disposable = null; // this should cleanup previous disposable away d.Dispose(); Assert.IsTrue(d.IsDisposed, "#1"); Assert.AreEqual(0, i, "#2"); }
public void DisposesUnderlyingDisposableOnce() { var disposed = 0; var subject = new MultipleAssignmentDisposable { Disposable = Disposable.Create(() => ++ disposed) }; Assert.AreEqual(0, disposed); for (var i = 0; i < 2; ++i) { subject.Dispose(); Assert.AreEqual(1, disposed); } }
public void MultipleAssignment() { var d = new MultipleAssignmentDisposable(); 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 MultipleAssignmentDisposable(); 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 MultipleAssignmentDisposable(); id1 = new IdDisp(1); id2 = new IdDisp(2); id3 = new IdDisp(3); d.Disposable = id1; d.Disposable = id2; d.Disposable = id3; d.Dispose(); id1.IsDisposed.IsFalse(); id2.IsDisposed.IsFalse(); id3.IsDisposed.IsTrue(); // null d = new MultipleAssignmentDisposable(); id1 = new IdDisp(1); d.Disposable = null; d.Dispose(); d.Disposable = null; }
public static void MultipleAssignmentDisposable_WillAllowRotatingTheUnderlyingDisposable_WithoutDisposingOfTheReplacedDisposable() { var multipleAssignmentDisposable = new MultipleAssignmentDisposable(); var notDisposedDisposable = Disposable.Create(() => Console.WriteLine("Wouldn't you believe it, I ain't gonna be disposed. Estupido!")); var replacementDisposable = Disposable.Create(() => Console.WriteLine("I'm gonna be disposed by disposing of the multi assignement disposable.")); multipleAssignmentDisposable.Disposable = notDisposedDisposable; multipleAssignmentDisposable.Disposable = replacementDisposable; Console.WriteLine("The switch has been made, but the replaced disposable has not been disposed."); Console.WriteLine("Disposing of the multi assignement disposable."); multipleAssignmentDisposable.Dispose(); Console.WriteLine($"Multi assignement disposable is disposed: {multipleAssignmentDisposable.IsDisposed}."); }
public void Dispose() { lock (_subscription) { if (_state == State.Disposed) { return; } _emitter.Dispose(); _queue = null; _completion = null; _state = State.Disposed; _subscription.Dispose(); } }
public void ReplacingDisposableDoesNotCauseItToBeDisposed() { var first = 0; var subject = new MultipleAssignmentDisposable { Disposable = Disposable.Create(() => ++ first) }; var second = 0; subject.Disposable = Disposable.Create(() => ++ second); Assert.AreEqual(0, first); Assert.AreEqual(0, second); subject.Dispose(); Assert.AreEqual(0, first); Assert.AreEqual(1, second); }
public async Task MultipleAssignmentDisposable_Test() { // arrange var d1 = new BooleanDisposable(); var d2 = new BooleanDisposable(); var d3 = new BooleanDisposable(); // arrange var disp = new MultipleAssignmentDisposable(); disp.Disposable = d1; // act & verify Assert.IsFalse(disp.IsDisposed); Assert.IsFalse(d1.IsDisposed); Assert.IsFalse(d2.IsDisposed); Assert.IsFalse(d3.IsDisposed); disp.Disposable = d2; disp.Dispose(); Assert.IsTrue(disp.IsDisposed); Assert.IsFalse(d1.IsDisposed); Assert.IsTrue(d2.IsDisposed); Assert.IsFalse(d3.IsDisposed); var gate = new ManualResetEventSlim(false); Task t = Task.Run(() => { gate.Wait(); disp.Disposable = d3; }); gate.Set(); await t; Assert.IsTrue(disp.IsDisposed); Assert.IsFalse(d1.IsDisposed); Assert.IsTrue(d2.IsDisposed); Assert.IsTrue(d3.IsDisposed); }
public static Func <Action <TResult>, Action <Exception>, IBackgroundTask> CreateForAsync <TResult>(FSharpAsync <TResult> async) { return((onSuccess, onError) => { var disp = new MultipleAssignmentDisposable(); var backgroundTask = new AnonymousBackgroundTask(); backgroundTask.name = "upgarde firmware"; backgroundTask.state = BackgroundTaskState.InProgress; backgroundTask.disposable = Disposable.Create(() => { disp.Dispose(); backgroundTask.state = BackgroundTaskState.Canceled; }); disp.Disposable = async.Subscribe( res => { onSuccess(res); backgroundTask.state = BackgroundTaskState.Completed; }, err => { onError(err); backgroundTask.state = BackgroundTaskState.Failed; } ); return backgroundTask; }); }
public void Dispose() { _disposables?.Dispose(); _subscriptionDisposable.Dispose(); }
public void Dispose() => _disposable.Dispose();
public void Dispose() { _disposable.Dispose(); }
public void Dispose() { stopper.Dispose(); }