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