C# ObservableDictionary.Last方法代码示例

        public void RemoveNotifiesRemovalAsResetIfRequestedTest(int initialDictionarySize, int amountOfItemsToRemove)
        {
            if (amountOfItemsToRemove > initialDictionarySize)
                throw new ArgumentOutOfRangeException(nameof(amountOfItemsToRemove), $"Must be less than {nameof(initialDictionarySize)}");

            // given
            var scheduler = new TestScheduler();

            var initialValues = Enumerable.Range(0, initialDictionarySize).ToDictionary(item => item, item => $"#{item}");
            var observer = scheduler.CreateObserver<IObservableDictionaryChange<int, string>>();
            var resetsObserver = scheduler.CreateObserver<Unit>();

            using (var observableDictionary = new ObservableDictionary<int, string>(initialValues, scheduler: scheduler))
            {
                // when
                observableDictionary.ThresholdAmountWhenChangesAreNotifiedAsReset = 0;

                using (observableDictionary.DictionaryChanges.Subscribe(observer))
                {
                    using (observableDictionary.Resets.Subscribe(resetsObserver))
                    {
                        var removedKeyValuePairs = new List<KeyValuePair<int, string>>();

                        for (int i = 0; i < amountOfItemsToRemove; i++)
                        {
                            var lastEntry = observableDictionary.Last();
                            observableDictionary.Remove(lastEntry.Key);

                            removedKeyValuePairs.Add(lastEntry);

                            scheduler.AdvanceBy(2);
                        }

                        // then
                        observableDictionary.Count.Should().Be(initialDictionarySize - amountOfItemsToRemove);

                        observer.Messages.Count.Should().Be(amountOfItemsToRemove);
                        resetsObserver.Messages.Count.Should().Be(amountOfItemsToRemove);

                        if (initialDictionarySize > 0)
                        {
                            observer.Messages.Select(message => message.Value.Value.ChangeType).Should().OnlyContain(changeType => changeType == ObservableDictionaryChangeType.Reset);

                            observer.Messages.Select(message => message.Value.Value.Key).Should().Match(ints => ints.All(@int => Equals(default(int), @int)));
                            observer.Messages.Select(message => message.Value.Value.Value).Should().Match(strings => strings.All(@string => Equals(default(string), @string)));
                        }
                    }
                }
            }
        }

        public void RemoveNotifiesCountDecrease(int initialDictionarySize, int amountOfItemsToRemove)
        {
            if (amountOfItemsToRemove > initialDictionarySize)
                throw new ArgumentOutOfRangeException(nameof(amountOfItemsToRemove), $"Must be less than {nameof(initialDictionarySize)}");

            // given
            var initialValues = Enumerable.Range(0, initialDictionarySize).ToDictionary(item => item, item => $"#{item}");

            int observableReportedCount = initialValues.Count;
            int countChangesCalled = 0;

            using (var observableDictionary = new ObservableDictionary<int, string>(initialValues))
            {
                // when
                observableDictionary.ThresholdAmountWhenChangesAreNotifiedAsReset = int.MaxValue;
                observableDictionary.CountChanges.Subscribe(i =>
                {
                    observableReportedCount = i;
                    countChangesCalled++;
                });

                for (int i = 0; i < amountOfItemsToRemove; i++)
                {
                    observableDictionary.Remove(observableDictionary.Last().Key);
                }

                // then check whether all items have been accounted for
                var expectedCount = initialDictionarySize - amountOfItemsToRemove;

                observableReportedCount.Should().Be(expectedCount); // +1 because the upper for loop goes up to & inclusive the upperLimit
                observableReportedCount.Should().Be(observableDictionary.Count);

                countChangesCalled.Should().Be(amountOfItemsToRemove);
            }
        }

        public void ObservableDictionaryExtensions_Last_ReturnsLastItemInObservableDictionary()
        {
            var dictionary = new ObservableDictionary<Int32, String>()
            {
                { 1, "A" },
                { 2, "B" },
                { 3, "C" },
            };

            var result = dictionary.Last();

            TheResultingValue(result).ShouldBe(new KeyValuePair<Int32, String>(3, "C"));
        }

        public void ObservableDictionaryExtensions_Last_ThrowsExceptionIfObservableDictionaryIsEmpty()
        {
            var dictionary = new ObservableDictionary<Int32, String>();

            Assert.That(() => dictionary.Last(),
                Throws.TypeOf<InvalidOperationException>());
        }

        public void ObservableDictionaryExtensions_Last_ThrowsExceptionIfObservableDictionaryIsEmpty()
        {
            var dictionary = new ObservableDictionary<Int32, String>();

            dictionary.Last();
        }