C# ReactiveList.RemoveAt方法代码示例

        public ObserveWindowViewModel( string filename, IActorRef tailCoordinator )
        {
            _tailCoordinator = tailCoordinator;
            Filename = filename;
            Title = filename;
            Items = new ReactiveList<String>();

            // start coordinator
            _tailCoordinator.Tell( new TailCoordinatorActor.StartTail( filename, this ) );

            // this is how we can update the viewmodel
            // from the actor.
            Lines = new Subject<String>();
            Lines.ObserveOnDispatcher().Subscribe( item =>
            {
                Items.Add( item );

                if ( Items.Count > 1500 )
                {
                    Items.RemoveAt( 0 );
                }

                SelectedLine = Items.Count - 1;

            } );
        }

        public MainWindowModel()
        {
            Tweets = new ReactiveList<TweetViewModel>();

            LoadTweets = ReactiveCommand.CreateAsyncTask(async _ =>
            {
                await Task.Delay(2000);
                foreach (var t in FakeData.GetFakeTweets())
                    Tweets.Add(t);
            });

            var canRemoveTweet = this.WhenAnyValue(vm => vm.Tweets.Count)
                .Select(c => c > 0);

            RemoveTweet = ReactiveCommand.Create(canRemoveTweet);
            RemoveTweet.Subscribe(_ => Tweets.RemoveAt(0));
        }

        public void CollectionCountChangedTest()
        {
            var fixture = new ReactiveList<int>();
            var before_output = new List<int>();
            var output = new List<int>();

            fixture.CountChanging.Subscribe(before_output.Add);
            fixture.CountChanged.Subscribe(output.Add);

            fixture.Add(10);
            fixture.Add(20);
            fixture.Add(30);
            fixture.RemoveAt(1);
            fixture.Clear();

            var before_results = new[] { 0, 1, 2, 3, 2 };
            Assert.AreEqual(before_results.Length, before_output.Count);

            var results = new[] { 1, 2, 3, 2, 0 };
            Assert.AreEqual(results.Length, output.Count);
        }

        public void DerivedCollectionsShouldRaiseListChangedEvents()
        {
            var input = new[] { "Foo", "Bar", "Baz", "Bamf" };
            var fixture = new ReactiveList<TestFixture>(
                input.Select(x => new TestFixture() { IsOnlyOneWord = x }));
            
            IBindingList output = fixture.CreateDerivedBindingList(new Func<TestFixture, string>(x => x.IsOnlyOneWord));
            var capturedEvents = new List<ListChangedEventArgs>();
            output.ListChanged += (o, e) => capturedEvents.Add(e);

            input.AssertAreEqual((IEnumerable<string>)output);

            fixture.Add(new TestFixture() { IsOnlyOneWord = "Hello" });
            Assert.Equal(capturedEvents.Last().ListChangedType,ListChangedType.ItemAdded);
            Assert.Equal(5, output.Count);
            Assert.Equal("Hello", output[4]);

            fixture.RemoveAt(4);
            Assert.Equal(capturedEvents.Last().ListChangedType, ListChangedType.ItemDeleted);
            Assert.Equal(4, output.Count);

            //replacing results in 
            //1 itemdeleted
            //2 itemadded
            fixture[1] = new TestFixture() { IsOnlyOneWord = "Goodbye" };
            Assert.Equal(4, output.Count);
            Assert.Equal("Goodbye", output[1]);
            Assert.Equal(capturedEvents[capturedEvents.Count - 2].ListChangedType, ListChangedType.ItemDeleted);
            Assert.Equal(capturedEvents[capturedEvents.Count - 1].ListChangedType, ListChangedType.ItemAdded);

            fixture.Clear();
            Assert.Equal(0, output.Count);
            Assert.Equal(capturedEvents.Last().ListChangedType, ListChangedType.Reset);
        }

		public SmoothDrawView(RectangleF frame, UIColor drawingColor, float lineThickness) : base(frame){
			paths = new ReactiveList<List<UIBezierPath>> ();

			this.BackgroundColor = UIColor.Clear;

			strokeColor = drawingColor ?? UIColor.Yellow;

			this.lineThickness = lineThickness;

			this.MultipleTouchEnabled = false;

			undo = new FlatButton(RectangleF.Empty);
			undo.Alpha = default(float);
			undo.SetTitle ("Undo", UIControlState.Normal);
			undo.SetBackgroundColor (MobileCore.Values.Colors.WhiteSeventyFivePercent.ToNative (), UIControlState.Normal);
			undo.SetTitleColor (MobileCore.Values.Colors.DarkGray.ToNative (), UIControlState.Normal);
			Add (undo);

			this.SubviewsDoNotTranslateAutoresizingMaskIntoConstraints ();

			this.AddConstraints (
				undo.AtBottomOf(this, Constants.Layout.VerticalPadding),
				undo.AtRightOf(this, Constants.Layout.HorizontalPadding),
				undo.Width().GreaterThanOrEqualTo(56f),
				undo.Height().GreaterThanOrEqualTo(32f)
			);
				
			Observable.CombineLatest (
				this.WhenAnyValue (x => x.Enabled),
				paths.CountChanged.StartWith(0),
				(enabled, count) => enabled && count > 0)
				.ObserveOn(RxApp.MainThreadScheduler)
				.Subscribe (shouldDisplay => UIView.AnimateAsync(Constants.Animation.StandardAnimationDuration, () => undo.Alpha = shouldDisplay ? 1.0f : default(float) ));

			this.WhenAnyValue (vm => vm.Enabled)
				.ObserveOn(RxApp.MainThreadScheduler)
				.Subscribe (enabled => UserInteractionEnabled = enabled);

			Observable.FromEventPattern(h => undo.TouchUpInside += h, h => undo.TouchUpInside -= h)
				.Where(_ => paths.Any())
				.ObserveOn(RxApp.MainThreadScheduler)
				.Subscribe(_ => {
					paths.RemoveAt (paths.Count - 1);

					this.SetNeedsDisplay ();
					});
		}

        public void AutoPersistCollectionDisconnectsOnDispose()
        {
            (new TestScheduler()).With(sched => {
                var manualSave = new Subject<Unit>();

                var item = new TestFixture();
                var fixture = new ReactiveList<TestFixture> { item };

                int timesSaved = 0;
                var disp = fixture.AutoPersistCollection(x => { timesSaved++; return Observable.Return(Unit.Default); }, manualSave, TimeSpan.FromMilliseconds(100));

                sched.AdvanceByMs(2 * 100);
                Assert.Equal(0, timesSaved);

                // By being added to collection, AutoPersist is enabled for item
                item.IsNotNullString = "Foo";
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);

                // Dispose = no save
                disp.Dispose();

                // Removed from collection = no save
                fixture.Clear();
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);

                // Item isn't in the collection, it doesn't get persisted anymore
                item.IsNotNullString = "Bar";
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);

                // Added back item + dispose = no save
                fixture.Add(item);
                sched.AdvanceByMs(100);  // Compensate for scheduling
                item.IsNotNullString = "Baz";
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);

                // Even if we issue a reset, no save
                fixture.Reset();
                sched.AdvanceByMs(100);  // Compensate for scheduling
                item.IsNotNullString = "Bamf";
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);

                // Remove by hand = no save
                fixture.RemoveAt(0);
                item.IsNotNullString = "Blomf";
                sched.AdvanceByMs(2 * 100);
                Assert.Equal(1, timesSaved);
            });
        }