C# CompositeDisposable.Dispose方法代码示例

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

        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 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 void CountAndDispose()
 {
     var d = new CompositeDisposable (Disposable.Empty);
     Assert.AreEqual (1, d.Count, "#1");
     d.Dispose ();
     Assert.AreEqual (0, d.Count, "#2");
 }

        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>
        ///     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;
        }

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