C# PagedCollectionView.RemoveAt方法代码示例

        public void OnCollectionChangedTest()
        {
            List<EditableTestClass> efbList = new List<EditableTestClass>();
            ObservableCollection<TestClass> fbCollection = new ObservableCollection<TestClass>();

            PagedCollectionView pcv1 = new PagedCollectionView(efbList);
            PagedCollectionView pcv2 = new PagedCollectionView(fbCollection);
            pcv1.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv2.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.Refresh(); });

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { fbCollection.Clear(); });

            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { fbCollection.Add(new TestClass()); });

            EditableTestClass efb;
            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { efb = pcv1.AddNew() as EditableTestClass; });

            pcv1.CommitNew();

            // Add, then Cancel to fire a Remove
            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { pcv1.AddNew(); });

            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.CancelNew(); });

            // Set PageSize to 1 to Reset
            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.PageSize = 1; });

            // Remove an Item
            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.RemoveAt(0); });

            pcv2.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv1.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
        }

        public void SortingWithLocalizationTest()
        {
            ObservableCollection<object> list = new ObservableCollection<object>() { "al:tinda", "ch:aque", "Cz:ech", "co:te", "hi:zli", "i:erigiyle" };

            PagedCollectionView view = new PagedCollectionView(list);

            // first test with the default InvariantCulture to see that it sorts in the correct order
            view.Culture = CultureInfo.InvariantCulture;
            view.SortDescriptions.Add(new SortDescription("", ListSortDirection.Descending));

            Assert.AreEqual(view[0], "i:erigiyle");
            Assert.AreEqual(view[1], "hi:zli");
            Assert.AreEqual(view[2], "Cz:ech");
            Assert.AreEqual(view[3], "co:te");
            Assert.AreEqual(view[4], "ch:aque");
            Assert.AreEqual(view[5], "al:tinda");

            // now test with a Slovik culture applied to make sure that it sorts in the correct order
            view.Culture = new CultureInfo("sk-SK");
            view.Refresh();

            Assert.AreEqual(view[0], "i:erigiyle");
            Assert.AreEqual(view[1], "ch:aque");
            Assert.AreEqual(view[2], "hi:zli");
            Assert.AreEqual(view[3], "Cz:ech");
            Assert.AreEqual(view[4], "co:te");
            Assert.AreEqual(view[5], "al:tinda");

            // now remove the second item and re-insert to verify that sorting with the CultureInfo 
            // allows it to be placed back in the same index
            view.RemoveAt(1);
            string str = "ch:aque";
            list.Add(str);
            Assert.AreEqual(str, view[1]);
        }

        public void AddRemoveEventsWithListBoxTest()
        {
            ObservableCollection<TestClass> collection = new ObservableCollection<TestClass>()
            {
                new TestClass { IntProperty = 1, StringProperty = "A" },
                new TestClass { IntProperty = 1, StringProperty = "C" },
                new TestClass { IntProperty = 2, StringProperty = "D" }
            };

            PagedCollectionView cv = new PagedCollectionView(collection);

            ListBox lb = new ListBox();
            lb.ItemsSource = cv;

            this.CreateAsyncTask(
                lb,
                delegate
                {
                    Assert.AreEqual(3, lb.Items.Count);

                    cv.AddNew();
                    cv.CommitNew();
                    Assert.AreEqual(4, lb.Items.Count);

                    cv.RemoveAt(3);
                    Assert.AreEqual(3, lb.Items.Count);

                    cv.SortDescriptions.Add(new System.ComponentModel.SortDescription("StringProperty", System.ComponentModel.ListSortDirection.Ascending));

                    TestClass newItem1 = new TestClass() { StringProperty = "B", IntProperty = 2 };
                    collection.Add(newItem1);

                    // Should have inserted into due to sorting
                    // {A, [B], C, D}
                    Assert.AreEqual(1, cv.IndexOf(newItem1));
                    Assert.AreEqual(1, lb.Items.IndexOf(newItem1));

                    cv.GroupDescriptions.Add(new PropertyGroupDescription("IntProperty"));

                    // Should now be grouped as
                    // {1A, 1C}
                    // {2B, 2D}
                    Assert.AreEqual(2, lb.Items.IndexOf(newItem1));

                    TestClass newItem2 = new TestClass() { StringProperty = "E", IntProperty = 1 };
                    collection.Add(newItem2);

                    // Should have inserted into due here to sorting/grouping
                    // {1A, 1C, [1E]}
                    // {2B, 2D}
                    Assert.AreEqual(2, cv.IndexOf(newItem2));
                    Assert.AreEqual(2, lb.Items.IndexOf(newItem2));

                    // Testing that with sorting/grouping, item is removed from the correct index
                    cv.RemoveAt(1);
                    Assert.AreEqual(newItem2, lb.Items[1]);

                    // Test 'Replace' operation.
                    TestClass newItem3 = new TestClass() { StringProperty = "F", IntProperty = 2 };
                    TestClass replacedItem = collection[0];
                    collection[0] = newItem3;

                    // This operation should have deleted old and added new
                    // {[-deleted-], 1E}
                    // {2B, 2D, [2F]}
                    Assert.AreEqual(-1, lb.Items.IndexOf(replacedItem));
                    Assert.AreEqual(3, lb.Items.IndexOf(newItem3));
                });

            EnqueueTestComplete();
        }