C# ObservableList.RemoveAt方法代码示例

 public void RemoveItemAfterSubscribing()
 {
     var source = new ObservableList<ObservableList<string>>();
     ImmutableList<string> result = ImmutableList<string>.Empty;
     source.ToLiveLinq()
         .SelectMany((list, _) => list.ToLiveLinq())
         .ToObservableEnumerable().Subscribe(value => result = value);
     source.Add(new ObservableList<string>());
     source.RemoveAt(0);
     result.Should().BeEmpty();
 }

 public void DisposeSubscription_ThenRemoveItem()
 {
     var source = new ObservableList<ObservableList<string>>();
     ImmutableList<string> result = ImmutableList<string>.Empty;
     var subscription = source.ToLiveLinq()
         .SelectMany((list, _) => list.ToLiveLinq())
         .ToObservableEnumerable().Subscribe(value => result = value);
     source.Add(new ObservableList<string>());
     source.Add(new ObservableList<string>());
     source[0].Add("a");
     source[1].Add("c");
     subscription.Dispose();
     source.RemoveAt(1);
     result.Should().ContainInOrder("a", "c");
 }

 public void ChangeCollection()
 {
   _handle = new EventWaitHandle(false, EventResetMode.ManualReset);
   var test = new ObservableList<string>();
   test.Changed += List_Changed;
   test.Add("myValue");
   Assert.IsTrue(_handle.WaitOne(10), "Add() is not recognized as a change");
   _handle.Reset();
   test[0] = "newValue";
   Assert.IsTrue(_handle.WaitOne(10), "this[] is not recognized as a change");
   _handle.Reset();
   test.RemoveAt(0);
   Assert.IsTrue(_handle.WaitOne(10), "RemoveAt() is not recognized as a change");
   _handle.Reset();
   test.Add("myValue");
   Assert.IsTrue(_handle.WaitOne(10), "Add() is not recognized as a change");
   _handle.Reset();
   test.Remove("myValue");
   Assert.IsTrue(_handle.WaitOne(10), "Remove() is not recognized as a change");
 }

        public void event_raised_when_item_is_removed_by_index()
        {
            var testObject = new ObservableList<int>();

            var events = new List<NotifyCollectionChangedEventArgs>();

            testObject.Add(1);
            testObject.Add(2);
            testObject.Add(3);

            var itemRemoved = 2;

            testObject.CollectionChanged += (source, args) => events.Add(args);

            testObject.RemoveAt(1);

            Assert.Equal(1, events.Count);

            var ev = events[0];
            Assert.Equal(NotifyCollectionChangedAction.Remove, ev.Action);
            Assert.Equal(1, ev.OldItems.Count);
            Assert.Equal(itemRemoved, ev.OldItems[0]);
            Assert.Equal(1, ev.OldStartingIndex);
        }

        public void When_RemoveAt_Then_Action_Remove_Raised()
        {
            // Arrange
            var sut = new ObservableList<int>(new[] {10, 12, 18, 100});
            var results = new List<NotifyCollectionChangedEventArgs>();
            var expected = new[]
            {
                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, 12, 1),
                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, 100, 2),
            };
            sut.CollectionChanged += (o, e) => results.Add(e);

            // Act
            sut.RemoveAt(1);
            sut.RemoveAt(2);

            // Assert
            KKAssert.AreEqualByValue(expected, results);
        }

        public void RemoveAt_FiresCollectionChanged()
        {
            var list = new ObservableList<int> { 1, 2 };

            list.CollectionChanged += (sender, args) =>
            {
                Assert.AreEqual(NotifyCollectionChangedAction.Remove, args.Action);
                Assert.AreEqual(1, args.OldStartingIndex);
                Assert.IsTrue(new[] { 2 }.SequenceEqual(args.OldItems.Cast<int>()));
            };

            list.RemoveAt(1);
        }

        public void RemoveAtFiresListChangedEvent()
        {
            const string expectItem = "another string to remove";
            const int expectIndex = 1;
            var actualItem = "";
            var actualIndex = -1;

            var observableList = new ObservableList<string>(new[] { "Alpha", "Bravo", "Charlie", "Delta", "Echo" }.AsEnumerable());
            observableList.Insert(expectIndex, expectItem);
            observableList.ListChanged += (s, e) =>
                                              {
                                                  actualItem = e.Item;
                                                  actualIndex = e.Index;
                                              };
            observableList.RemoveAt(expectIndex);

            Assert.AreEqual(expectItem, actualItem);
            Assert.AreEqual(expectIndex, actualIndex);
        }

 public void TestRemoveAt()
 {
     var list = new List<string> { "aaa", "bbb", "ccc" };
     var set = new ObservableList<string>(list);
     Assert.AreEqual(set.Count, list.Count);
     bool propertyChangedInvoked = false;
     bool collectionChangedInvoked = false;
     set.PropertyChanged += (sender, e) =>
     {
         Assert.AreEqual(e.PropertyName, nameof(ObservableList<string>.Count));
         propertyChangedInvoked = true;
     };
     set.CollectionChanged += (sender, e) =>
     {
         Assert.AreEqual(e.Action, NotifyCollectionChangedAction.Remove);
         Assert.AreEqual(e.OldStartingIndex, 1);
         Assert.NotNull(e.OldItems);
         Assert.AreEqual(e.OldItems.Count, 1);
         Assert.AreEqual(e.OldItems[0], "bbb");
         collectionChangedInvoked = true;
     };
     set.RemoveAt(1);
     Assert.AreEqual(set.Count, 2);
     Assert.AreEqual(set[0], "aaa");
     Assert.AreEqual(set[1], "ccc");
     Assert.True(propertyChangedInvoked);
     Assert.True(collectionChangedInvoked);
 }