C# PagedCollectionView.AddNew方法代码示例

        public void GroupingInListBoxTest()
        {
            ObservableCollection<TestClass> collection = new ObservableCollection<TestClass>()
            {
                new TestClass { IntProperty = 1, StringProperty = "A" },
                new TestClass { IntProperty = 2, StringProperty = "B" }, 
                new TestClass { IntProperty = 3, StringProperty = "A" },
                new TestClass { IntProperty = 4, StringProperty = "B" } 
            };

            PagedCollectionView cv = new PagedCollectionView(collection);

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

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

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

                    Assert.AreEqual(4, lb.Items.Count);
                    Assert.AreEqual("A", (lb.Items[0] as TestClass).StringProperty);
                    Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                    Assert.AreEqual("B", (lb.Items[2] as TestClass).StringProperty);
                    Assert.AreEqual("B", (lb.Items[3] as TestClass).StringProperty);

                    cv.PageSize = 3;
                    cv.MoveToPage(1);

                    Assert.AreEqual(1, lb.Items.Count);
                    Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);

                    TestClass newItem = cv.AddNew() as TestClass;
                    newItem.StringProperty = "A";
                    newItem.IntProperty = 5;

                    // ---------------------
                    // |Page | 0  | 1  | 2  |
                    // ---------------------
                    // | 0   | A  | A  | B  |
                    // | 1   | B  |-A- |    | <---- Current Page
                    Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);
                    Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                    cv.CommitNew();

                    // ---------------------
                    // |Page | 0  | 1  | 2  |
                    // ---------------------
                    // | 0   | A  | A  |-A- |
                    // | 1   | B  | B  |    | <---- Current Page
                    Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);
                    Assert.AreEqual("B", (lb.Items[1] as TestClass).StringProperty);

                    cv.MoveToFirstPage();
                    Assert.AreEqual("A", (lb.Items[0] as TestClass).StringProperty);
                    Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                    Assert.AreEqual("A", (lb.Items[2] as TestClass).StringProperty);
                });

            EnqueueTestComplete();
        }

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

        public void CannotSortTest()
        {
            List<TestClass> intList = new List<TestClass>() { new TestClass() };
            PagedCollectionView pcv = new PagedCollectionView(intList);

            // we are not allowed to sort during an edit operation
            pcv.EditItem(pcv[0]);
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Sorting")),
                delegate
                {
                    pcv.SortDescriptions.Clear();
                });
            pcv.CommitEdit();

            // we are not allowed to sort during an add new operation
            pcv.AddNew();
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Sorting")),
                delegate
                {
                    pcv.SortDescriptions.Clear();
                });
        }

        public void CannotRefreshTest()
        {
            ObservableCollection<TestClass> collection = new ObservableCollection<TestClass>() { new TestClass() };
            PagedCollectionView pcv = new PagedCollectionView(collection);

            // show that we will throw an exception if we try to change the PageSize while adding
            pcv.AddNew();
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Refresh")),
                delegate
                {
                    pcv.Refresh();
                });
            pcv.CancelNew();

            // show that we will throw an exception if we try to change the PageSize while editing
            pcv.EditItem(pcv[0]);
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedDuringAddOrEdit, "Refresh")),
                delegate
                {
                    pcv.Refresh();
                });
        }

        public void CannotChangePageSize()
        {
            ObservableCollection<TestClass> collection = new ObservableCollection<TestClass>() { new TestClass() };
            PagedCollectionView pcv = new PagedCollectionView(collection);

            // show that we will throw an exception if we try to change the PageSize while adding
            pcv.AddNew();
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(PagedCollectionViewResources.ChangingPageSizeNotAllowedDuringAddOrEdit),
                delegate
                {
                    pcv.PageSize = 10;
                });
            pcv.CancelNew();

            // show that we will throw an exception if we try to change the PageSize while editing
            pcv.EditItem(pcv[0]);
            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(PagedCollectionViewResources.ChangingPageSizeNotAllowedDuringAddOrEdit),
                delegate
                {
                    pcv.PageSize = 10;
                });
        }

        public void CannotAddNewTest()
        {
            // if the size of the collection is fixed, we are not allowed to add items to it.
            FixedSizeCollection<TestClass> fixedSizeCollection = new FixedSizeCollection<TestClass>();
            PagedCollectionView pcv1 = new PagedCollectionView(fixedSizeCollection);
            Assert.IsFalse(pcv1.CanAddNew);

            // if the item type does not have a constructor, we are not allowed to call AddNew.
            List<int> intList = new List<int>();
            PagedCollectionView pcv2 = new PagedCollectionView(intList);
            Assert.IsFalse(pcv2.CanAddNew);

            PagedCollectionViewTest.AssertExpectedException(
                new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, PagedCollectionViewResources.OperationNotAllowedForView, "AddNew")),
                delegate
                {
                    pcv2.AddNew();
                });
        }