C# ObservableList.Clear方法代码示例

 public LocationsTreeViewModel(ObservableCollection<Location> locations)
 {
     Locations = new ObservableList<LocationNode>();
     foreach (var location in locations) Locations.Add(new LocationNode(location));
     locations.CollectionChanged += (s, e) =>
     {
         switch (e.Action)
         {
             case NotifyCollectionChangedAction.Add:
                 foreach (Location location in e.NewItems) Locations.Add(new LocationNode(location));
                 break;
             case NotifyCollectionChangedAction.Remove:
                 foreach (Location location in e.OldItems)
                 {
                     var item = Locations.FirstOrDefault(l => l.Location.Guid == location.Guid);
                     if (item != null) Locations.Remove(item);
                 }
                 break;
             case NotifyCollectionChangedAction.Replace:
                 foreach (Location location in e.OldItems)
                 {
                     var item = Locations.FirstOrDefault(l => l.Location.Guid == location.Guid);
                     if (item != null) Locations.Remove(item);
                 }
                 foreach (Location location in e.NewItems) Locations.Add(new LocationNode(location));
                 break;
             case NotifyCollectionChangedAction.Reset:
                 Locations.Clear();
                 foreach (Location location in e.NewItems) Locations.Add(new LocationNode(location));
                 break;
         }
     };
     LocationsTreeViewSource = new CollectionViewSource { Source = Locations };
     LocationsTreeViewSource.SortDescriptions.Add(new SortDescription("Location.Name", ListSortDirection.Ascending));
 }

        public void CanAccumulate()
        {
            var items = new ObservableList<Person>();


            var subscription = items.Changes
                .Subscribe(changes =>
                {
                    Console.WriteLine(changes);
                });


            using (var x = items.SuspendNotifications())
            {
                foreach (var person in _random.Take(20000))
                {
                    items.Add(person);
                }
                items.Clear();
                var result = items.GetChanges();

                items[10] = new Person("Roland", 1);
            }

        }

        public void ClearFiresListClearedEvent()
        {
            var didFire = false;
            var observableList = new ObservableList<string> { "it doesn't matter" };

            observableList.ListCleared += (s, e) => { didFire = true; };
            observableList.Clear();

            Assert.IsTrue(didFire);
        }

        public void ObservableList_RaisesCollectionResetOnClear()
        {
            var list  = new ObservableList<Int32>();
            var reset = false;

            list.CollectionReset += (source) =>
            {
                reset = true;
            };
            list.Add(1234);
            list.Clear();

            TheResultingValue(reset).ShouldBe(true);
        }

        public void Clearing_the_list_raises_property_changed()
        {
            var observable = new ObservableList<string>();
            var propertyChangedRaised = false;
            observable.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == "Clear")
                    propertyChangedRaised = true;
            };

            observable.Clear();

            Assert.IsTrue(propertyChangedRaised);
        }

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

            // Act
            sut.Clear();

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

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

            var events = new List<NotifyCollectionChangedEventArgs>();

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

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

            testObject.Clear();

            Assert.Equal(1, events.Count);

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

 public void ClearWithNoEventListenerClearsList()
 {
     var observableList = new ObservableList<DateTime> { DateTime.Now, new DateTime(2001, 5, 4) };
     observableList.Clear();
     CollectionAssert.IsEmpty(observableList.ToArray());
 }

 public void TestClear()
 {
     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.Reset);
         collectionChangedInvoked = true;
     };
     set.Clear();
     Assert.AreEqual(set.Count, 0);
     Assert.True(propertyChangedInvoked);
     Assert.True(collectionChangedInvoked);
 }