C# ObservableDictionary.Add方法代码示例

        public void ShouldBindBetweenIndexedObjects()
        {
            var binder = new Binder<ObservableDictionary<UniversalStub>>();

            var dict= new ObservableDictionary<UniversalStub>();

            binder.BindIf(x => x.ContainsKey("first") && x.ContainsKey("second"), x => x["first"].String).To(x => x["second"].String);

            using (binder.Attach(dict))
            {
                var first = new UniversalStub();
                var second = new UniversalStub { String = "a" };
                dict.Add("second", second);
                second.String.ShouldBe("a");
                using (second.VerifyChangedOnce("String"))
                {
                    dict.Add("first", first);
                }
                second.String.ShouldBe(null);

                using (second.VerifyChangedOnce("String"))
                {
                    first.String = "b";
                }
                second.String.ShouldBe("b");
            }
        }

 public void ToDictionary_Unset_Set()
 {
     var source = new ObservableDictionary<int, string>();
     var get2 = Nothing<string>();
     source.ToLiveLinq()[2].Subscribe(val => get2 = val);
     get2.Should().Be(Nothing<string>());
     source.Add(2, "Hi there");
     get2.Should().Be(Something("Hi there"));
     source.Remove(2);
     get2.Should().Be(Nothing<string>());
     source.Add(2, "Hello");
     get2.Should().Be(Something("Hello"));
 }

 public void AddItem()
 {
   _handle = new EventWaitHandle(false, EventResetMode.ManualReset);
   var test = new ObservableDictionary<int, string>();
   test.ItemAdded += Dictionary_ItemEvent;
   test.Add(0, "myValue");
   Assert.IsTrue(_handle.WaitOne(10));
 }

 public MainView()
 {
     channels = new ObservableDictionary<string, ChannelViewModel>();
     channels.Add("#speedrunslive", new ChannelViewModel { Title = "#speedrunslive" });
     channels.Add("#bingo", new ChannelViewModel { Title = "#bingo" });
     pinnedChannels = new ObservableDictionary<string, ChannelViewModel>();
     pinnedChannels.Add("#speedrunslive", new ChannelViewModel { Title = "#speedrunslive" });
     pinnedChannels.Add("#bingo", new ChannelViewModel { Title = "#bingo" });
     messages = new ObservableCollection<Message>();
     var msg = Message.ParseString(":BOB!asdf PART #speedrunslive :how's it going");
     var msg1 = Message.ParseString(":BOB!asdf JOIN #speedrunslive :how's it going");
     var msg2 = Message.ParseString(":BOB!asdf NOTICE #speedrunslive :how's it going");
     var msg3 = Message.ParseString(":BOB!asdf PRIVMSG #bingo :how's it goingkjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj");
     MessageAdded(msg);
     MessageAdded(msg1);
     MessageAdded(msg2);
     MessageAdded(msg3);
 }

        public void ObservableDictionaryAddItemTest()
        {
            ObservableDictionary<GenericParameterHelper, GenericParameterHelper> target = new ObservableDictionary<GenericParameterHelper, GenericParameterHelper>();
            target.CollectionChanged += delegate(object sender, NotifyCollectionChangedEventArgs e) {
                Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action);
                Assert.IsNotNull(e.NewItems);
            };

            KeyValuePair<GenericParameterHelper, GenericParameterHelper> item = new KeyValuePair<GenericParameterHelper, GenericParameterHelper>(new GenericParameterHelper(1), new GenericParameterHelper(1));
            target.Add(item);
            Assert.AreEqual(1, target.Count);
        }

    private Run(Run original, Cloner cloner)
      : base(original, cloner) {
      color = original.color;
      algorithm = cloner.Clone(original.algorithm);

      parameters = new ObservableDictionary<string, IItem>();
      foreach (string key in original.parameters.Keys)
        parameters.Add(key, cloner.Clone(original.parameters[key]));

      results = new ObservableDictionary<string, IItem>();
      foreach (string key in original.results.Keys)
        results.Add(key, cloner.Clone(original.results[key]));
    }

 public void ChangeCollection()
 {
   _handle = new EventWaitHandle(false, EventResetMode.ManualReset);
   var test = new ObservableDictionary<int, string>();
   test.Changed += Dictionary_Changed;
   test.Add(0, "myValue");
   Assert.IsTrue(_handle.WaitOne(10), "Add() is not recognized as a change");
   _handle.Reset();
   test[0] = "newValue";
   Assert.IsTrue(_handle.WaitOne(10), "this[] is not recognized as a change");
   _handle.Reset();
   test.Remove(0);
   Assert.IsTrue(_handle.WaitOne(10), "Remove() is not recognized as a change");
 }

        /// <summary>
        /// <para>Creates a <see cref="ObservableDictionary<string, bool>"/> that contains all available <see cref="TaskPlugin"/>s and loads their values from the settings</para>
        /// </summary>
        /// <param name="Main"></param>
        /// <returns></returns>
        public static ObservableDictionary<string, bool> GetPluginsAll(Main Main)
        {
            ObservableDictionary<string, bool> setting = GetPluginsSetting();

            ObservableDictionary<string, bool> plugins = new ObservableDictionary<string, bool>();
            foreach (Type task in Main.TaskMgr.TaskPluginsAvailable)
            {
                string name = task.Name;
                bool enabled = true;
                if (setting.ContainsKey(name))
                    enabled = setting[name];
                plugins.Add(name, enabled);
            }

            return plugins;
        }

        public void DictionaryChangesObserverExceptionsShouldBeThrownIfUnhandled()
        {
            // given
            using (var observableDictionary = new ObservableDictionary<int, string>())
            {
                observableDictionary.DictionaryChanges.Subscribe(_ =>
                {
                    throw new InvalidOperationException("My Marker Message");
                });

                // when
                Action action = () => observableDictionary.Add(1, "One");

                // then
                action
                    .ShouldThrow<InvalidOperationException>()
                    .WithMessage("My Marker Message");
            }
        }

        public void AddAddsItem()
        {
            // given
            var key = 1;
            var value = "One";

            using (var observableDictionary = new ObservableDictionary<int, string>())
            {
                // when
                observableDictionary.Add(key, value);

                // then check whether all items have been accounted for
                observableDictionary.Count.Should().Be(1);
                observableDictionary.Should().Contain(key, value);

                observableDictionary.Keys.Should().Contain(key);
                observableDictionary.Values.Should().Contain(value);
            }
        }

        public void CountChangesObserverExceptionsShouldNotBeThrownIfHandledViaUnhandledObserverExceptionsObservable()
        {
            // given
            using (var observableDictionary = new ObservableDictionary<int, string>())
            {
                observableDictionary.ObserverExceptions.Subscribe(observerException =>
                {
                    observerException.Handled = true;
                });

                observableDictionary.CountChanges.Subscribe(_ =>
                {
                    throw new InvalidOperationException("My Marker Message");
                });

                // when
                Action action = () => observableDictionary.Add(1, "One");

                // then
                action.ShouldNotThrow<InvalidOperationException>();
            }
        }

        public void ShouldNotNotifySubscribersAboutValueChangesAfterItemsAreRemovedFromDictionary()
        {
            // given
            var scheduler = new TestScheduler();

            int key = 1;
            var testInpcImplementationInstance = new MyNotifyPropertyChanged<int, string>(key);

            var observer = scheduler.CreateObserver<IObservableDictionaryChange<int, MyNotifyPropertyChanged<int, string>>>();
            var itemChangesObserver = scheduler.CreateObserver<IObservableDictionaryChange<int, MyNotifyPropertyChanged<int, string>>>();

            using (var observableDictionary = new ObservableDictionary<int, MyNotifyPropertyChanged<int, string>>(scheduler: scheduler))
            {
                observableDictionary.ThresholdAmountWhenChangesAreNotifiedAsReset = int.MaxValue;

                IDisposable dictionaryChangesSubscription = null;
                IDisposable dictionaryItemChangesSubscription = null;

                try
                {
                    dictionaryChangesSubscription = observableDictionary.DictionaryChanges.Subscribe(observer);
                    dictionaryItemChangesSubscription = observableDictionary.ValueChanges.Subscribe(itemChangesObserver);

                    // when
                    observableDictionary.Add(key, testInpcImplementationInstance); // first general message - ItemAdd
                    testInpcImplementationInstance.FirstProperty = Guid.NewGuid().ToString(); // second general / first item change message - ItemChanged
                    observableDictionary.Remove(key); // third general message - ItemRemoved
                    testInpcImplementationInstance.SecondProperty = Guid.NewGuid().ToString(); // should no longer be observable on/via dictionary

                    scheduler.AdvanceBy(100);

                    // then
                    observer.Messages.Count.Should().Be(3);
                    observer.Messages[0].Value.Value.ChangeType.Should().Be(ObservableDictionaryChangeType.ItemAdded);
                    observer.Messages[0].Value.Value.Key.Should().Be(key);
                    observer.Messages[0].Value.Value.Value.Should().Be(testInpcImplementationInstance);

                    observer.Messages[1].Value.Value.ChangeType.Should().Be(ObservableDictionaryChangeType.ItemValueChanged);
                    observer.Messages[1].Value.Value.Key.Should().Be(default(int));
                    observer.Messages[1].Value.Value.Value.Should().Be(testInpcImplementationInstance);
                    observer.Messages[1].Value.Value.OldValue.Should().BeNull();
                    observer.Messages[1].Value.Value.ChangedPropertyName.Should().Be(nameof(MyNotifyPropertyChanged<int, string>.FirstProperty));

                    observer.Messages[2].Value.Value.ChangeType.Should().Be(ObservableDictionaryChangeType.ItemRemoved);
                    observer.Messages[2].Value.Value.Key.Should().Be(key);
                    observer.Messages[2].Value.Value.Value.Should().Be(testInpcImplementationInstance);

                    itemChangesObserver.Messages.Count.Should().Be(1);
                    itemChangesObserver.Messages.First().Value.Value.ChangeType.Should().Be(ObservableDictionaryChangeType.ItemValueChanged);
                    itemChangesObserver.Messages.First().Value.Value.Key.Should().Be(default(int));
                    itemChangesObserver.Messages.First().Value.Value.Value.Should().Be(testInpcImplementationInstance);
                    itemChangesObserver.Messages.First().Value.Value.OldValue.Should().BeNull();
                    itemChangesObserver.Messages.First().Value.Value.ChangedPropertyName.Should().Be(nameof(MyNotifyPropertyChanged<int, string>.FirstProperty));
                }
                finally
                {
                    dictionaryChangesSubscription?.Dispose();
                    dictionaryItemChangesSubscription?.Dispose();
                }
            }
        }

        public void RemoveRaisesPropertyChangedEventForItemIndexerAndCount()
        {
            // given
            using (var observableDictionary = new ObservableDictionary<int, string>())
            {
                observableDictionary.Add(1, "One");

                observableDictionary.MonitorEvents();

                // when
                observableDictionary.Remove(1);

                // then
                observableDictionary
                    .ShouldRaise(nameof(observableDictionary.PropertyChanged))
                    .WithSender(observableDictionary)
                    .WithArgs<PropertyChangedEventArgs>(args => args.PropertyName == "Item[]");

                observableDictionary
                    .ShouldRaise(nameof(observableDictionary.PropertyChanged))
                    .WithSender(observableDictionary)
                    .WithArgs<PropertyChangedEventArgs>(args => args.PropertyName == nameof(observableDictionary.Count));
            }
        }

        public void AddShouldThrowOnNullKey()
        {
            // given
            using (var observableDictionary = new ObservableDictionary<string, string>())
            {
                // when
                Action action = () => observableDictionary.Add(null, null);

                // then
                action
                    .ShouldThrow<ArgumentNullException>()
                    .WithMessage("Value cannot be null.\r\nParameter name: key");

                observableDictionary.Count.Should().Be(0);
            }
        }

        /// <summary>
        ///     The class constructor.
        /// </summary>
        /// <param name="bench"> Reference to dynBench object for logging </param>
        public SearchViewModel()
        {
            SelectedIndex = 0;
            RevitApiSearchElements = new List<SearchElementBase>();
            NodeCategories = new Dictionary<string, CategorySearchElement>();
            SearchDictionary = new SearchDictionary<SearchElementBase>();
            SearchResults = new ObservableCollection<SearchElementBase>();
            MaxNumSearchResults = 20;
            Visible = Visibility.Collapsed;
            _SearchText = "";
            IncludeRevitAPIElements = false; // revit api
            Regions = new ObservableDictionary<string, RegionBase>();
            //Regions.Add("Include Nodes from Package Manager", DynamoCommands.PackageManagerRegionCommand );
            Regions.Add("Include Experimental Revit API Nodes", new RevitAPIRegion());

            _topResult = this.AddRootCategory("Top Result");
            this.AddRootCategory(BuiltinNodeCategories.CORE);
            this.AddRootCategory(BuiltinNodeCategories.LOGIC);
            this.AddRootCategory(BuiltinNodeCategories.CREATEGEOMETRY);
            this.AddRootCategory(BuiltinNodeCategories.MODIFYGEOMETRY);
            this.AddRootCategory(BuiltinNodeCategories.REVIT);
            this.AddRootCategory(BuiltinNodeCategories.IO);
            this.AddRootCategory(BuiltinNodeCategories.SCRIPTING);
            this.AddRootCategory(BuiltinNodeCategories.ANALYZE);
        }