protected override void OnAttached() { base.OnAttached(); _disposables?.Dispose(); _disposables = new CompositeDisposable(); OnAttached(_disposables); }
protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e) { base.OnDetachedFromVisualTree(e); _disposables?.Dispose(); _captionButtons?.Detach(); _captionButtons = null; }
public void AddAfterDisposal() { int i1 = 0, i2 = 0; var d = new CompositeDisposable (); d.Add (Disposable.Create (() => i1++)); d.Dispose (); Assert.AreEqual (1, i1, "#1"); d.Dispose (); Assert.AreEqual (1, i1, "#2"); // no further addition d.Add (Disposable.Create (() => i2++)); Assert.AreEqual (1, i2, "#3"); d.Dispose (); Assert.AreEqual (1, i2, "#4"); // no further addition d.Add (Disposable.Create (() => i2++)); // should be immediately disposed Assert.AreEqual (2, i2, "#5"); }
public void DisposeTest() { var disposes = new CompositeDisposable(); var dis1 = new DisposeObject1(); disposes.Dispose(); disposes.AddDisposable(new DisposeObject1()); }
public IDisposable ShowView(FrameworkElement view) { var disp = new CompositeDisposable(); disp.Add(scheduler.Schedule(() => { disp.Add(showView(view)); })); return Disposable.Create(() => { scheduler.Schedule(() => { disp.Dispose(); }); }); }
public void AddTwice() { int i = 0; var d = new CompositeDisposable (); var item = Disposable.Create (() => i++); d.Add (item); d.Add (item); // this results in two items registered. Assert.AreEqual (2, d.Count, "#1"); d.Dispose (); // though, since the first disposal takes effect, it never invokes Dispose() on item twice. Assert.AreEqual (1, i, "#2"); }
protected virtual void Dispose(bool disposing) { if (!_disposedValue) { if (disposing) { _disposables?.Dispose(); _disposables = null; } _disposedValue = true; } }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { _Trashes?.Dispose(); } _disposed = true; }
public void when_Dispose_is_called_then_added_IDisposable_is_disposed() { var disposables = new CompositeDisposable(); var eventWasFired = false; var disposable = AnonymousDisposable.Create(() => eventWasFired = true); disposables.Add(disposable); Assert.That(eventWasFired, Is.False); disposables.Dispose(); Assert.That(eventWasFired, Is.True); }
public override void Awake() { var app = AppController.Instance; this.coinNumberText.text = string.Format("{0:000}", app.Coin); this.damageNumberText.text = string.Format("{0:000}", app.Damage); this.usedInkNumberText.text = string.Format("{0:000}", app.UsedInk); var resources = new CompositeDisposable(); // startAction function // return Action<Vector3, IObservable<Vector3>> // paras: before = MouseDownStream, stream == MouseUpStream Action<Vector3, IObservable<Vector3>> startAction = (before, stream) => { // after == Drag.MouseUpStream stream.First() .Subscribe(after => { if (Vector3.Distance(before, after) <= 0.3f) { resources.Dispose(); Application.LoadLevel("Title"); } }); }; Drag.MouseDownStream() .Subscribe(before => { startAction(before, Drag.MouseUpStream()); }) .AddTo(resources); Drag.TouchStartStream() .Subscribe(beforeTouch => { var before = Camera.main.ScreenToWorldPoint(beforeTouch.Item1.position); startAction(before, Drag.TouchUpStream(beforeTouch.Item1.fingerId) .Select(touch => Camera.main.ScreenToWorldPoint(touch.Item1.position))); }) .AddTo(resources); base.Awake(); }
public void Test() { var disposes = new CompositeDisposable(); var dis1 = new DisposeObject1(); var dis2 = new DisposeObject2(); Assert.IsFalse(disposes.IsDisposed); Assert.IsFalse(dis1.IsDisposed); Assert.IsFalse(dis2.IsDisposed); disposes.AddDisposable(dis1); disposes.AddDisposable(dis2); disposes.Dispose(); Assert.IsTrue(disposes.IsDisposed); Assert.IsTrue(dis1.IsDisposed); Assert.IsTrue(dis2.IsDisposed); }
public MainForm() { InitializeComponent(); components = new NestedContainer(this); var uiThread = new SynchronizationContextScheduler(SynchronizationContext.Current); var subscriptions = new CompositeDisposable( RxMessageBrokerMinimod.Default.Register<Log>(m => { Debug.WriteLine(m.Message); var addedIndex = lbxEvents.Items.Add(m.Message); lbxEvents.SelectedIndex = addedIndex; }, uiThread), RxMessageBrokerMinimod.Default.Register<CurrentFile>(m => { lblCurrentFile.Text = m.FileName; lblLength.Text = m.Length.ToString(); }, uiThread)); components.Add(new Disposer(_ => subscriptions.Dispose())); }
public EnumItemsControl() { this.SetValue(ItemsControlEx.ArrangementProperty, Arrangement.Wrapped); CompositeDisposable?disposable = null; this.WhenAnyValue(a => a.Enum) .CombineLatest(this.WhenAnyValue(a => a.IsReadOnly)) .Select(a => BuildFromEnum(a.First, a.Second).ToArray()) .Subscribe(enums => { Output = enums.First().Enum; disposable?.Dispose(); disposable = new(); ItemsSource = enums; foreach (var item in enums) { item.Command.Subscribe(a => { Output = a; }).DisposeWith(disposable); } }); }
public void Dispose() { _bag?.Dispose(); }
private void OnDisable() { m_subscriptions?.Dispose(); }
private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e) { additionallocalization_images = new CompositeDisposable(clear_additional_locs()); var s = new CompositeDisposable(additionallocalization_images as IDisposable); var image_obs = VM.ObservableForProperty(x => x.MapImage).Value() .StartWith(VM.MapImage).Where(img => img != null); s.Add(image_obs.Subscribe(img => { ImgZoom.Source = img; })); _currentPos = new RelativeLocationBinding(currentPosImg, update_transform, VM.ObservableForProperty(x => x.CurrentLocation).Value().StartWith(VM.CurrentLocation).Select(ScaleToImage)); s.Add(_currentPos); _currentLoc = new RelativeLocationBinding(currentLocalizationImg, update_transform, VM.ObservableForProperty(x => x.PrimaryLocalization).Value().StartWith(VM.PrimaryLocalization).Select(ScaleToImage)); s.Add(_currentLoc); s.Add( VM.AdditionalLocalizations .ObserveOnDispatcher() .Do(_ => additionallocalization_images.Dispose()) .SelectMany(p => p) .ObserveOnDispatcher() .Subscribe(p => { var it = ScaleToImage(p); var source = this.Resources["GPSPointImage"] as BitmapImage; if(source != null) { var img = new Image() { Source = source, Height = source.PixelHeight, Width = source.PixelWidth }; var binding = new RelativeLocationBinding(img, update_transform) { RelativeLocation = it }; additionallocalization_images.Add(binding); MainCanvas.Children.Add(img); } })); subscriptions = s; }
/// <summary> /// Disposes this ObservableAsPropertyHelper. /// </summary> public void Dispose() { _disposable?.Dispose(); _disposable = null !; }
/// <inheritdoc/> protected override void OnDetached() => _disposable?.Dispose();
private void TransientContainer_Unloaded(object sender, RoutedEventArgs e) { _AnimationCts?.Dispose(); _AnimationCts = null; _CompositeDisposable?.Dispose(); }
public void Cleanup() { _subscriptions?.Dispose(); }
public void Dispose() { _disposables?.Dispose(); _lockReleaser.Dispose(); }
public virtual void Dispose() { compositeDisposable?.Dispose(); }
public void Dispose() { disposables?.Dispose(); Dispose(true); GC.SuppressFinalize(this); }
public void Dispose() { OnDispose(); _CompositeDisposable?.Dispose(); }
public void Dispose() { _disposable?.Dispose(); }
public void Remove() { disposables?.Dispose(); ProductionIsFinished = null; }
public void Dispose() { subscriptions?.Dispose(); }
public void Dispose() { _compositeDisposable?.Dispose(); }
void OnDisable() { _disposables?.Dispose(); }
public void Dispose() { Disposables?.Dispose(); }
/// <summary> /// Requests loading the image of <paramref name="size"/> located on <paramref name="uri"/>. /// </summary> /// <param name="uri"> /// An uri of the image to load. /// </param> /// <param name="size"> /// The desired size of the image. /// </param> /// <param name="minSize"> /// Thi mimimum accetable size. /// </param> /// <returns> /// Returns an observable sequence which contains an image(s) of <paramref name="size"/> loaded using <paramref name="uri"/>. /// </returns> /// <remarks> /// If the image cannot be loaded or loaded image has smaller size than requested, then it tries to load the image using fallback /// <see cref="BaseImageLoader"/>. All intermediate images (the images of smaller size than requested), are pushed into observable sequence. /// </remarks> protected IObservable<ImageInfo> WhenLoaded(Uri uri, Size size, Size minSize) { var result = Observable.Create<ImageInfo>(observer => { ImageInfo image = null; var compositeDisposable = new CompositeDisposable(); compositeDisposable.Add(this.WhenLoadedInternal(uri, size).Subscribe( img => { observer.OnNext(img); image = img; }, err => { if (fallbackLoader != null) { compositeDisposable.Add(this.fallbackLoader.WhenLoaded(uri, size, minSize) .Do(this.OnFallbackImageLoaded) .Subscribe(observer)); } else { observer.OnError(err); } }, () => { if ((image == null || image.IsFittedIn(size) == false || image.ForceFallback) && fallbackLoader != null) { compositeDisposable.Add(this.fallbackLoader.WhenLoaded(uri, size, image == null ? minSize : image.Size) .Do(this.OnFallbackImageLoaded) .Subscribe(observer)); } else { observer.OnCompleted(); } })); return () => { compositeDisposable.Dispose(); }; }); return result; }
public void Dispose() { _msgSubscriptions?.Dispose(); }
public void Stop() { syncingDisposeBag?.Dispose(); syncingDisposeBag = new CompositeDisposable(); }
public void CountAndDispose() { var d = new CompositeDisposable (Disposable.Empty); Assert.AreEqual (1, d.Count, "#1"); d.Dispose (); Assert.AreEqual (0, d.Count, "#2"); }
protected virtual void Dispose(bool disposing) { _compositeDisposable?.Dispose(); Protocol?.Dispose(); }
public async Task BridgeTo(string destination, BridgeOptions options, Action<EventMessage> onProgress = null) { if (!IsAnswered && !IsPreAnswered) { return; } Log.Debug(() => "Channel {0} is attempting a bridge to {1}".Fmt(UUID, destination)); if (string.IsNullOrEmpty(options.UUID)) { options.UUID = Guid.NewGuid().ToString(); } var subscriptions = new CompositeDisposable(); subscriptions.Add( eventSocket.Events.Where(x => x.UUID == options.UUID) .Take(1) .Subscribe(x => Bridge = new BridgeStatus(false, "In Progress", new BridgedChannel(x, eventSocket)))); if (onProgress != null) { subscriptions.Add( eventSocket.Events.Where(x => x.UUID == options.UUID && x.EventName == EventName.ChannelProgress) .Take(1) .Subscribe(onProgress)); } var result = await eventSocket.Bridge(UUID, destination, options).ConfigureAwait(false); Log.Debug(() => "Channel {0} bridge complete {1} {2}".Fmt(UUID, result.Success, result.ResponseText)); subscriptions.Dispose(); Bridge = new BridgeStatus(result.Success, result.ResponseText, Bridge.Channel); }
public override void ViewDisappeared() { base.ViewDisappeared(); disposeBag?.Dispose(); }
public override void ViewDestroy(bool viewFinishing) { base.ViewDestroy(viewFinishing); disposeBag?.Dispose(); }
/// <inheritdoc/> public void Dispose() { subscriptions?.Dispose(); subscriptions = null; }
public override void ViewDestroyed() { base.ViewDestroyed(); disposeBag?.Dispose(); }
public void Dispose() { disposeBag?.Dispose(); dataSource?.Dispose(); tableView?.Dispose(); }
public virtual void OnBind() { disposables?.Dispose(); disposables = new(); }
static void SetupCommand(TaskCompletionSource<bool?> tcs, ReactiveCommand<bool?> command) { var d = new CompositeDisposable {command}; d.Add(command.ThrownExceptions.Subscribe(x => { tcs.SetException(x); d.Dispose(); })); d.Add(command.Subscribe(x => { tcs.SetResult(x); d.Dispose(); })); }