public void Dispose() { if (isDisposed) { return; } logger.Info($"{streamType}:"); DisableInput(); DisableTransfer(); playbackErrorSubject.Dispose(); _bufferingSubject.OnCompleted(); _bufferingSubject.Dispose(); _packetProcessed.OnCompleted(); _packetProcessed.Dispose(); transferCts?.Dispose(); linkedCts?.Dispose(); currentPacket?.Dispose(); isDisposed = true; }
protected virtual void Dispose(bool isDisposing) { if (_isDisposed) { return; } _isDisposed = true; if (isDisposing) { Disconnect().Wait(5000); _outMessages.Dispose(); _outMessages = null; _inMessages.Dispose(); _inMessages = null; _inMessagesHistory.Dispose(); _inMessagesHistory = null; _outMessagesHistory.Dispose(); _outMessagesHistory = null; } }
protected virtual void Dispose(bool disposing) { if (disposing) { _result.Dispose(); } }
private void Start() { // 過去3メッセージまでキャッシュするReplaySubject var subject = new ReplaySubject <int>(bufferSize: 3); //メッセージを発行 for (int i = 0; i < 10; i++) { subject.OnNext(i); } // OnCompletedメッセージもキャッシュされる subject.OnCompleted(); // OnErrorメッセージもキャッシュできる // subject.OnError(new Exception("Error!")); // 購読 subject.Subscribe( x => Debug.Log("OnNext:" + x), ex => Debug.LogError("OnError:" + ex), () => Debug.Log("OnCompleted")); subject.Dispose(); }
public void Dispose() { if (m_subject != null) { m_subject.Dispose(); } }
private void Dispose(bool disposing) { if (disposing) { _messageSubject?.Dispose(); } }
public override void Dispose() { base.Dispose(); actualItemSubject?.Dispose(); View?.Dispose(); }
public static IObservable <T> Pausable <T>( this IObservable <T> source, IObservable <bool> pauser) { return(Observable.Create <T>(o => { var paused = new SerialDisposable(); var subscription = Observable.Publish(source, ps => { var values = new ReplaySubject <T>(); Func <bool, IObservable <T> > switcher = b => { if (b) { values.Dispose(); values = new ReplaySubject <T>(); paused.Disposable = ps.Subscribe(values); return Observable.Empty <T>(); } else { return values.Concat(ps); } }; return pauser.StartWith(false).DistinctUntilChanged() .Select(p => switcher(p)) .Switch(); }).Subscribe(o); return new CompositeDisposable(subscription, paused); })); }
public void Dispose() { if (_workspaceFoldersSubject.IsDisposed) { return; } _workspaceFoldersSubject.Dispose(); }
public static void Broadcast <T>(IObservable <T> recievers, Action <T> lambda) { var broadcast = new ReplaySubject <T>(); broadcast.ForEachAsync(lambda); recievers.Subscribe(cl => broadcast.OnNext(cl), () => broadcast.OnCompleted()); broadcast.Dispose(); }
public void HasObservers_Dispose3() { var s = new ReplaySubject <int>(); Assert.IsFalse(s.HasObservers); s.Dispose(); Assert.IsFalse(s.HasObservers); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { _evictionEvent?.Dispose(); } }
private void DisposeAllSubjects() { playbackErrorSubject.Dispose(); stateChangedSubject.OnCompleted(); stateChangedSubject.Dispose(); bufferingProgressSubject.OnCompleted(); bufferingProgressSubject.Dispose(); logger.Info("End"); }
public void Dispose() { try { _subject.Dispose(); } catch (Exception) { } }
public void Initialized() { if (_delayComplete || _delayedQueue.IsDisposed || !_delayedQueue.HasObservers) { return; } _delayedQueue.OnCompleted(); _delayComplete = true; _delayedQueue.Dispose(); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (!disposing) { return; } _reputationEvent?.Dispose(); }
public void Dispose() { itemAddedSubject?.Dispose(); itemRemovedSubject?.Dispose(); itemUpdatedSubject?.Dispose(); foreach (var disposable in itemsDisposables) { disposable.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { _foundDeltaHeightSubject.Dispose(); } } _disposed = true; }
/// <inheritdoc /> public void Dispose() { this.Log().Info("Disposing MQTT subscription"); _restore.Dispose(); _subscription.Dispose(); _status.OnNext(MqttConnectionStatus.Disabled); _status.OnCompleted(); _status.Dispose(); }
public void Dispose() { if (_disposed) { return; } _payloadSequence.OnCompleted(); _payloadSequence.Dispose(); _disposed = true; }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { _subject.Dispose(); } disposedValue = true; } }
protected override void Dispose(bool disposing) { if (_disposed == false) { if (disposing) { Clear(); _recordersSubscription.Dispose(); _recordings.Dispose(); } _disposed = true; } base.Dispose(disposing); }
protected virtual void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { payloadSequence.OnCompleted(); payloadSequence.Dispose(); disposed = true; } }
private void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { _eventReplySubject.Dispose(); } _disposed = true; }
/// <summary> /// Disposes of resources inside the class. /// </summary> /// <param name="isDisposing">If we are disposing managed resources.</param> protected virtual void Dispose(bool isDisposing) { if (_isDisposed) { return; } if (isDisposing) { _activated?.Dispose(); } _isDisposed = true; }
protected override void Dispose(bool disposing) { if (_disposed == false) { if (disposing) { Disconnect(); _recording.Dispose(); _gazeSources.Dispose(); } _disposed = true; } base.Dispose(disposing); }
/// <summary> /// Disposes of the managed resources as well as the reporting channels /// </summary> public virtual void Dispose() { if (!IsDisposed) { IsDisposed = true; ManagedResources.DisposeAll(); ReportInformation.OnCompleted(); ReportExceptions.OnCompleted(); ReportInformation.Dispose(); ReportExceptions.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { _receiver.Dispose(); _subscription.Close(); _mqChannel.Close(); _mqConnection.Close(); _messageStream.OnCompleted(); _messageStream.Dispose(); } _disposed = true; } }
public void HasObservers_Dispose2() { var s = new ReplaySubject <int>(); Assert.IsFalse(s.HasObservers); var d = s.Subscribe(_ => { }); Assert.IsTrue(s.HasObservers); d.Dispose(); Assert.IsFalse(s.HasObservers); s.Dispose(); Assert.IsFalse(s.HasObservers); }
protected override void Dispose(bool disposing) { if (_disposed == false) { if (disposing) { TryCancel(); _events.Dispose(); //var recorders = _recorders.ToList(); //_recorders.Clear(); //recorders.OfType<IDisposable>().ForEach(r => r.Dispose()); } _disposed = true; } base.Dispose(disposing); }
/// <summary> /// Fires a stream of RoleIds when you should reload. /// This happens whenever an Observer is active and the RoleId has changed. /// </summary> /// <returns> /// An Observable that fires the RoleId whenever data should be updated. /// </returns> protected IObservable<Guid> SetupExecuteObservable() { var loadQuery = Manager.Context.RoleIdObservable; var combinedObservationStateChanges = this.ObservationState; //loadQuery.Subscribe(s => Debug.WriteLine(String.Format("{0} RoleId {1}", queryKey, s))); //combinedObservationStateChanges.Subscribe(s => Debug.WriteLine(String.Format("{0} ObservationState {1}", queryKey, s))); //See http://stackoverflow.com/questions/7716114/rx-window-join-groupjoin for explanation var loadQueryUpdatesWhileInactive = new ReplaySubject<Guid>(1); var disposer = new SerialDisposable(); //the getSwitch will //a) publish loadQueryUpdates if the observation state is active //b) track loadQueryUpdates when ObservationState = suspended, then publish the loadQueryUpdate once active Func<ObservationState, IObservable<ObservationState>, IObservable<Guid>, IObservable<Guid>> getSwitch = (observationStateUpdate, observationStateUpdates, loadQueryUpdates) => { //a) because the observationState is active publish the loadQueryUpdatesWhileInactive & the loadQueryUpdates if (observationStateUpdate == Common.Models.ObservationState.Active) { //Merge the loadQueryUpdatesWhileInactive with the loadQueryUpdates return loadQueryUpdatesWhileInactive.Merge(loadQueryUpdates); } //b) because the ObservationState is suspended: // setup loadQueryUpdatesWhileInactive to keep track of the loadQueryUpdates while inactive //dispose the last loadQueryUpdatesWhileInactive subscription loadQueryUpdatesWhileInactive.Dispose(); //setup loadQueryUpdatesWhileInactive to track 1 (the last) loadQuery update loadQueryUpdatesWhileInactive = new ReplaySubject<Guid>(1); //dispose the temporary subscription to loadQueryUpdates disposer.Disposable = //track loadQueryUpdates until the next observationStateUpdates loadQueryUpdates.TakeUntil(observationStateUpdates) .Subscribe(loadQueryUpdatesWhileInactive); //setup loadQueryUpdatesWhileInactive //return an Empty Guid Observable so that executeQuery does not publish anything return Observable.Empty<Guid>(); }; //Create an Observable that fires the RoleId whenever data should be updated //The logic for when it should fire is defined in the getSwitch var executeQuery = combinedObservationStateChanges.DistinctUntilChanged() //whenever the combineObservationState changes .Publish(observationStateUpdates => loadQuery //publish the observationStateUpdates .Publish(loadQueryUpdates => //publish the loadQueryUpdates observationStateUpdates.Select( //select according to the getSwitch logic observationStateUpdate => getSwitch(observationStateUpdate, observationStateUpdates, loadQueryUpdates)))) .Switch() .Throttle(new TimeSpan(0, 0, 0, 0, 200));//Throttle for .2 second so it does not execute too often executeQuery.Subscribe(s => Debug.WriteLine(String.Format("Load data for {0} with RoleId {1}", GetType(), s))); return executeQuery; }
public void HasObservers_Dispose2() { var s = new ReplaySubject<int>(); Assert.IsFalse(s.HasObservers); var d = s.Subscribe(_ => { }); Assert.IsTrue(s.HasObservers); d.Dispose(); Assert.IsFalse(s.HasObservers); s.Dispose(); Assert.IsFalse(s.HasObservers); }
private static void HasObservers_Dispose3(ReplaySubject<int> s) { Assert.False(s.HasObservers); Assert.False(s.IsDisposed); s.Dispose(); Assert.False(s.HasObservers); Assert.True(s.IsDisposed); }
private static void HasObservers_Dispose2(ReplaySubject<int> s) { Assert.False(s.HasObservers); Assert.False(s.IsDisposed); var d = s.Subscribe(_ => { }); Assert.True(s.HasObservers); Assert.False(s.IsDisposed); d.Dispose(); Assert.False(s.HasObservers); Assert.False(s.IsDisposed); s.Dispose(); Assert.False(s.HasObservers); Assert.True(s.IsDisposed); }
public void HasObservers_Dispose3() { var s = new ReplaySubject<int>(); Assert.IsFalse(s.HasObservers); s.Dispose(); Assert.IsFalse(s.HasObservers); }