public void Test_ObservableCollection_Remove() { var list = new ObservableCollection<int>() { 4, 5, 6 }; Assert.Equal(3, list.Count); list.Remove(4); Assert.Equal(2, list.Count); Assert.DoesNotContain(4, list); var collection = list as ICollection<int>; Assert.NotNull(collection); Assert.True(collection.Remove(5)); Assert.Equal(1, collection.Count); Assert.DoesNotContain(5, list); list = new ObservableCollection<int>() { 4, 5, 6 }; list.CollectionChanged += (o, e) => { Assert.Same(list, o); Assert.Equal(NotifyCollectionChangedAction.Remove, e.Action); Assert.Null(e.NewItems); Assert.NotNull(e.OldItems); Assert.Equal(1, e.OldItems.Count); Assert.Equal(5, e.OldItems[0]); }; list.RemoveAt(1); Assert.Equal(2, list.Count); Assert.DoesNotContain(5, list); }
static void Main() { ObservableCollection<string> items = new ObservableCollection<string>(); items.CollectionChanged += items_CollectionChanged; items.Add("new item"); items.Add("another item"); items.Add("one more item"); items[1] = "new value"; items.RemoveAt(0); }
/// <summary> /// Verifies that the item is removed from a given index in the collection. /// </summary> public void RemoveItemAtTest(ReadOnlyObservableCollection<string> readOnlyCol, ObservableCollection<string> collection, int itemIndex) { INotifyPropertyChanged readOnlyPropertyChanged = readOnlyCol; readOnlyPropertyChanged.PropertyChanged += Collection_PropertyChanged; _expectedPropertyChanged = new[] { new PropertyNameExpected(COUNT), new PropertyNameExpected(ITEMARRAY) }; INotifyCollectionChanged readOnlyCollectionChange = readOnlyCol; readOnlyCollectionChange.CollectionChanged += Collection_CollectionChanged; string itemAtOldIndex = collection[itemIndex]; _expectedCollectionChangedFired++; _expectedAction = NotifyCollectionChangedAction.Remove; _expectedNewItems = null; _expectedNewStartingIndex = -1; _expectedOldItems = new string[] { itemAtOldIndex }; _expectedOldStartingIndex = itemIndex; int expectedCount = collection.Count - 1; collection.RemoveAt(itemIndex); Assert.Equal(expectedCount, readOnlyCol.Count); Assert.Equal(_expectedCollectionChangedFired, _numCollectionChangedFired); foreach (var item in _expectedPropertyChanged) Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we replaced an item"); readOnlyCollectionChange.CollectionChanged -= Collection_CollectionChanged; readOnlyPropertyChanged.PropertyChanged -= Collection_PropertyChanged; }
public static void RemoveAtTest_Negative() { Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() }; ObservableCollection<Guid> collection = new ObservableCollection<Guid>(anArray); ReadOnlyObservableCollection<Guid> readonlyCol = new ReadOnlyObservableCollection<Guid>(collection); ((INotifyCollectionChanged)readonlyCol).CollectionChanged += (o, e) => { throw new ShouldNotBeInvokedException(); }; int[] iArrInvalidValues = new Int32[] { -1, -2, -100, -1000, -10000, -100000, -1000000, -10000000, -100000000, -1000000000, Int32.MinValue }; foreach (var index in iArrInvalidValues) { Assert.Throws<ArgumentOutOfRangeException>(() => collection.RemoveAt(index)); Assert.Equal(anArray.Length, readonlyCol.Count); } int[] iArrLargeValues = new Int32[] { collection.Count, Int32.MaxValue, Int32.MaxValue / 2, Int32.MaxValue / 10 }; foreach (var index in iArrLargeValues) { Assert.Throws<ArgumentOutOfRangeException>(() => collection.RemoveAt(index)); Assert.Equal(anArray.Length, readonlyCol.Count); } }
public static void RemoveAtTest_Negative() { Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() }; ObservableCollection<Guid> collection = new ObservableCollection<Guid>(anArray); collection.CollectionChanged += (o, e) => { Assert.True(false, "Should not have thrown collection changed event when removing items from invalid indices"); }; int[] iArrInvalidValues = new Int32[] { -1, -2, -100, -1000, -10000, -100000, -1000000, -10000000, -100000000, -1000000000, Int32.MinValue }; foreach (var index in iArrInvalidValues) { Assert.Throws<ArgumentOutOfRangeException>(() => collection.RemoveAt(index)); Assert.Equal(anArray.Length, collection.Count); } int[] iArrLargeValues = new Int32[] { collection.Count, Int32.MaxValue, Int32.MaxValue / 2, Int32.MaxValue / 10 }; foreach (var index in iArrLargeValues) { Assert.Throws<ArgumentOutOfRangeException>(() => collection.RemoveAt(index)); Assert.Equal(anArray.Length, collection.Count); } }
public static void RemoveAtTest() { Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() }; ObservableCollection<Guid> col0 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray); ObservableCollection<Guid> col1 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray); ObservableCollection<Guid> col2 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray); col0.RemoveAt(0); string collectionString = ""; foreach (var item in col1) collectionString += item + ", "; Assert.False(col0.Contains(anArray[0]), "Collection0 should no longer contain the item: " + anArray[0] + " Collection: " + collectionString); col1.RemoveAt(1); collectionString = ""; foreach (var item in col1) collectionString += item + ", "; Assert.False(col1.Contains(anArray[1]), "Collection1 should no longer contain the item: " + anArray[1] + " Collection: " + collectionString); col2.RemoveAt(2); collectionString = ""; foreach (var item in col2) collectionString += item + ", "; Assert.False(col2.Contains(anArray[2]), "Collection2 should no longer contain the item: " + anArray[2] + " Collection: " + collectionString); string[] anArrayString = { "one", "two", "three", "four" }; ObservableCollection<string> col = new ObservableCollection<string>(anArrayString); CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester(); helper.RemoveItemAtTest(col, 1); }
public async Task OnRemoveNotifyCollectionChangedThenIndexProvided() { await ExecuteOnUIThread(() => { var originalCollection = new ObservableCollection<ItemMetadata>(); originalCollection.Add(new ItemMetadata("a")); originalCollection.Add(new ItemMetadata("b")); originalCollection.Add(new ItemMetadata("c")); IViewsCollection viewsCollection = new ViewsCollection(originalCollection, (i) => true); var eventTracker = new CollectionChangedTracker(viewsCollection); originalCollection.RemoveAt(1); var removeEvent = eventTracker.NotifyEvents.Single(e => e.Action == NotifyCollectionChangedAction.Remove); Assert.IsNotNull(removeEvent); Assert.AreEqual(1, removeEvent.OldStartingIndex); }); }
/// <summary> /// Removes a set of tracks from a given collection of tracks. /// </summary> /// <param name="tracksToRemove">The tracks to remove</param> /// <param name="tracks">The collection from where to remove the tracks</param> /// <param name="progressDelta">The amount to increase the scanner progressbar for total scan</param> private void RemoveTracks(SortedList<string, TrackData> tracksToRemove, ObservableCollection<TrackData> tracks, double progressDelta = -1) { //double progress = 0; //double trackDelta = 0; //if (progressDelta > 0) //{ // Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate() // { // trackDelta = progressDelta / tracks.Count; // progress = ScanProgressBar.Value; // })); //} for (int i = 0, j=0; i < tracks.Count; i++,j++) { if (tracksToRemove.ContainsKey(tracks[i].Path)) { Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate() { tracks.RemoveAt(i--); })); } //if (progressDelta > 0) //{ // if (j % 100 == 0 || (int)progress % 10 == 0) // Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate() // { // ScanProgressBar.Value += progressDelta; // })); // progress += trackDelta; //} } }
/// <summary> /// Checks the object validation for fields warnings or errors. /// </summary> /// <param name="value">The value.</param> /// <param name="propertyChanged">The property changed.</param> /// <param name="infoList">The info list containing the warning or error info.</param> /// <param name="validationType">Type of the validation.</param> private static void CheckObjectValidationForFields(object value, string propertyChanged, ObservableCollection<FieldWarningOrErrorInfo> infoList, ValidationType validationType) { if (string.IsNullOrEmpty(propertyChanged)) { infoList.Clear(); } else { for (int i = 0; i < infoList.Count; i++) { if (string.Compare(infoList[i].Field, propertyChanged) == 0) { infoList.RemoveAt(i); } } } Dictionary<string, string> fieldWarningsOrErrors = CheckFieldWarningsOrErrors(value, propertyChanged, validationType); foreach (var fieldWarningOrError in fieldWarningsOrErrors) { var fieldWarningOrErrorInfo = new FieldWarningOrErrorInfo(fieldWarningOrError.Key, fieldWarningOrError.Value); if (!infoList.Contains(fieldWarningOrErrorInfo)) { infoList.Add(new FieldWarningOrErrorInfo(fieldWarningOrError.Key, fieldWarningOrError.Value)); } } }
private void UpdateUnconsumedProperties(CategoryEditor newEditor, ObservableCollection<PropertyEntry> unconsumedProperties) { for (int i = unconsumedProperties.Count - 1; i >= 0; i--) { if (newEditor.ConsumesProperty(unconsumedProperties[i])) { unconsumedProperties.RemoveAt(i); } } }
public void SetItemsSourceAndModifyCollection() { // Create the DataGrid and setup its binding ObservableCollection<string> strings = new ObservableCollection<string>() { "one", "two", "three" }; bool isLoaded = false; DataGrid dataGrid = new DataGrid(); dataGrid.Loaded += delegate { isLoaded = true; }; // Set the ItemsSource and verify the slot counts dataGrid.ItemsSource = strings; dataGrid.SelectedIndex = 0; Assert.AreEqual(3, dataGrid.SlotCount, "Incorrect SlotCount after setting ItemsSource"); Assert.AreEqual(3, dataGrid.VisibleSlotCount, "Incorrect VisibleSlotCount after setting ItemsSource"); Assert.AreEqual(0, dataGrid.SelectedIndex, "SelectedIndex incorrect"); // Remove an item and verify that the DataGrid is updated strings.RemoveAt(1); Assert.AreEqual(2, dataGrid.SlotCount, "Incorrect SlotCount after removing an item"); Assert.AreEqual(2, dataGrid.VisibleSlotCount, "Incorrect VisibleSlotCount after removing an item"); Assert.AreEqual(0, dataGrid.SelectedIndex, "SelectedIndex incorrect after removing an item"); // Add an item and verify that the DataGrid is updated strings.Add("four"); Assert.AreEqual(3, dataGrid.SlotCount, "Incorrect SlotCount after adding an item"); Assert.AreEqual(3, dataGrid.VisibleSlotCount, "Incorrect VisibleSlotCount after adding an item"); Assert.AreEqual(0, dataGrid.SelectedIndex, "SelectedIndex incorrect after adding an item"); // Insert an item an dverify that the DataGrid is updated strings.Insert(0, "zero"); Assert.AreEqual(4, dataGrid.SlotCount, "Incorrect SlotCount after inserting an item"); Assert.AreEqual(4, dataGrid.VisibleSlotCount, "Incorrect VisibleSlotCount after inserting an item"); Assert.AreEqual(1, dataGrid.SelectedIndex, "SelectedIndex incorrect after inserting an item"); // Add the DataGrid to the visual tree TestPanel.Children.Add(dataGrid); this.EnqueueConditional(delegate { return isLoaded; }); this.EnqueueYieldThread(); this.EnqueueCallback(delegate { Assert.AreEqual(4, dataGrid.SlotCount, "Incorrect SlotCount after adding and removing items"); Assert.AreEqual(4, dataGrid.VisibleSlotCount, "Incorrect VisibleSlotCount after adding and removing items"); Assert.AreEqual(1, dataGrid.SelectedIndex, "SelectedIndex was not updated when collection changed"); Assert.AreEqual("one", dataGrid.SelectedItem, "SelectedItem was not updated when collection changed"); DataGridRow row = dataGrid.DisplayData.GetDisplayedRow(0); Assert.IsNotNull(row); Assert.AreEqual(0, row.Slot, "Incorrect Row.Slot"); Assert.AreEqual(0, row.Index, "Incorrect Row.Index"); Assert.AreEqual("zero", row.DataContext, "Incorrect Row.DataContext"); row = dataGrid.DisplayData.GetDisplayedRow(1); Assert.IsNotNull(row); Assert.AreEqual(1, row.Slot, "Incorrect Row.Slot"); Assert.AreEqual(1, row.Index, "Incorrect Row.Index"); Assert.AreEqual("one", row.DataContext, "Incorrect Row.DataContext"); row = dataGrid.DisplayData.GetDisplayedRow(2); Assert.IsNotNull(row); Assert.AreEqual(2, row.Slot, "Incorrect Row.Slot"); Assert.AreEqual(2, row.Index, "Incorrect Row.Index"); Assert.AreEqual("three", row.DataContext, "Incorrect Row.DataContext"); row = dataGrid.DisplayData.GetDisplayedRow(3); Assert.IsNotNull(row); Assert.AreEqual(3, row.Slot, "Incorrect Row.Slot"); Assert.AreEqual(3, row.Index, "Incorrect Row.Index"); Assert.AreEqual("four", row.DataContext, "Incorrect Row.DataContext"); }); this.EnqueueTestComplete(); }
// keep inner and outer CollViews' GroupDescription collections in synch private void SynchronizeGroupDescriptions(NotifyCollectionChangedEventArgs e, ObservableCollection<GroupDescription> origin, ObservableCollection<GroupDescription> clone) { if (clone == null) return; // the clone might be lazily-created _groupBy int i; switch (e.Action) { case NotifyCollectionChangedAction.Add: Debug.Assert(e.NewStartingIndex >= 0); if (clone.Count + e.NewItems.Count != origin.Count) goto case NotifyCollectionChangedAction.Reset; for (i = 0; i < e.NewItems.Count; i++) { clone.Insert(e.NewStartingIndex + i, (GroupDescription) e.NewItems[i]); } break; case NotifyCollectionChangedAction.Remove: Debug.Assert(e.OldStartingIndex >= 0); if (clone.Count - e.OldItems.Count != origin.Count) goto case NotifyCollectionChangedAction.Reset; for (i = 0; i < e.OldItems.Count; i++) { clone.RemoveAt(e.OldStartingIndex); } break; case NotifyCollectionChangedAction.Replace: Debug.Assert(e.OldStartingIndex >= 0); if (clone.Count + e.NewItems.Count - e.OldItems.Count != origin.Count) goto case NotifyCollectionChangedAction.Reset; // If there are as many new items as old items, then // this is a straight replace. if (e.OldItems.Count == e.NewItems.Count) { for (i = 0; i < e.OldItems.Count; i++) { clone[e.OldStartingIndex + i] = (GroupDescription) e.NewItems[i]; } } else { for (i = 0; i < e.OldItems.Count; i++) { clone.RemoveAt(e.OldStartingIndex); } for (i = 0; i < e.NewItems.Count; i++) { clone.Insert(e.NewStartingIndex + i, (GroupDescription) e.NewItems[i]); } } break; case NotifyCollectionChangedAction.Move: Debug.Assert(e.OldStartingIndex >= 0); if (clone.Count != origin.Count) goto case NotifyCollectionChangedAction.Reset; if (e.OldItems.Count == 1) { clone.Move(e.OldStartingIndex, e.NewStartingIndex); } else { if (e.NewStartingIndex < e.OldStartingIndex) { for (i = 0; i < e.OldItems.Count; i++) { clone.Move(e.OldStartingIndex + i, e.NewStartingIndex + i); } } else if (e.NewStartingIndex > e.OldStartingIndex) { for (i = e.OldItems.Count - 1; i >= 0; i--) { clone.Move(e.OldStartingIndex + i, e.NewStartingIndex + i); } } } break; // this arm also handles cases where the two collections have gotten // out of [....] (typically because exceptions prevented a previous [....] // from happening) case NotifyCollectionChangedAction.Reset: CloneList(clone, origin); break; default: throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action)); } }
//ObservableCollectionTest public static void ObservableCollectionTest() { var data = new ObservableCollection<string>(); data.CollectionChanged += new NotifyCollectionChangedEventHandler(DataCollectionChanged); data.Add("One"); data.Add("Two"); data.Add("Three"); data.Insert(1,"$^^$"); data.RemoveAt(1); foreach (var tmp in data) { Console.WriteLine(tmp); } }
public void OnRemoveOfFilterMatchingItemThenViewCollectionRelativeIndexProvided() { var originalCollection = new ObservableCollection<ItemMetadata>(); originalCollection.Add(new ItemMetadata("a")); originalCollection.Add(new ItemMetadata("b")); originalCollection.Add(new ItemMetadata("c")); IViewsCollection viewsCollection = new ViewsCollection(originalCollection, (i) => !"b".Equals(i.Item)); var eventTracker = new CollectionChangedTracker(viewsCollection); originalCollection.RemoveAt(2); var removeEvent = eventTracker.NotifyEvents.Single(e => e.Action == NotifyCollectionChangedAction.Remove); Assert.IsNotNull(removeEvent); Assert.AreEqual(1, removeEvent.OldStartingIndex); }
/// <summary> /// Removes tracks with a given filename for a specific collection of tracks /// </summary> /// <param name="filename">The filename of the tracks to remove</param> /// <param name="tracks">The collection of tracks from which to remove</param> private void RemoveTrack(String filename, ObservableCollection<TrackData> tracks) { for (int i = 0; i < tracks.Count; i++) { if (tracks[i].Path == filename) { tracks.RemoveAt(i); break; } } }
public void RemovingFromFilteredCollectionDoesNotThrow() { var originalCollection = new ObservableCollection<ItemMetadata>(); originalCollection.Add(new ItemMetadata("a")); originalCollection.Add(new ItemMetadata("b")); originalCollection.Add(new ItemMetadata("c")); IViewsCollection viewsCollection = new ViewsCollection(originalCollection, (i) => true); CollectionViewSource cvs = new CollectionViewSource {Source = viewsCollection}; var view = cvs.View; try { originalCollection.RemoveAt(1); } catch (Exception ex) { Assert.Fail(ex.Message); } }
//我要刺杀函数 public void Kill() { CancelSelect(); Step = 3; IsCenterHeroVisable = true; CenterHeros = new ObservableCollection<Hero>(); CardRes.Heros.ForEach(x => CenterHeros.Add(x)); CenterHeros.RemoveAt(0); CenterHeros.RemoveAt(0); }