C# PagedCollectionView.IndexOf方法代码示例

        public void InsertWithSortingOnUnsharedPropertyTest()
        {
            // we will create a collection of type object, with instances of ClassA and ClassB,
            // which are not related classes. however, they share a property of the same name and type
            ObservableCollection<object> collection = new ObservableCollection<object>()
            {
                new ClassA(){IntProperty=1, SomeProperty="A"},
                new ClassB(){IntProperty=3, SomeProperty=true},
                new ClassA(){IntProperty=5, SomeProperty="B"},
                new ClassB(){IntProperty=7, SomeProperty=false},
            };

            PagedCollectionView pcv = new PagedCollectionView(collection);

            // first verify that we can sort
            pcv.SortDescriptions.Add(new SortDescription("IntProperty", ListSortDirection.Descending));

            Assert.AreEqual(typeof(ClassB), pcv[0].GetType());
            Assert.AreEqual(typeof(ClassA), pcv[1].GetType());
            Assert.AreEqual(typeof(ClassB), pcv[2].GetType());
            Assert.AreEqual(typeof(ClassA), pcv[3].GetType());

            // next insert an item and verify that it gets correctly inserted based on
            // the correct sort index
            ClassA addItem = new ClassA() { IntProperty = 4, SomeProperty = "C" };
            collection.Add(addItem);
            Assert.AreEqual(2, pcv.IndexOf(addItem));

            // now test on the other property that has the same name
            // but different type. we should not get an error, and just
            // treat the variable as a null or default value
            pcv.SortDescriptions.Clear();
            pcv.SortDescriptions.Add(new SortDescription("SomeProperty", ListSortDirection.Ascending));

            Assert.AreEqual("3 True", pcv[0].ToString());
            Assert.AreEqual("7 False", pcv[1].ToString()); 
            Assert.AreEqual("1 A", pcv[2].ToString());
            Assert.AreEqual("5 B", pcv[3].ToString());
            Assert.AreEqual("4 C", pcv[4].ToString());
        }

        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();
        }