C# ObservableCollection.Insert方法代码示例

        public LayersWindow(MapControl mapControl)
        {
            InitializeComponent();
            _mapControl = mapControl;
            _model = new ObservableCollection<LayerViewModel>();
            if (mapControl.mapBox.Map.Layers != null && mapControl.mapBox.Map.Layers.Count > 0) {
                foreach (ILayer layer in mapControl.mapBox.Map.Layers) {
                    if (layer is VectorLayer) {
                        _model.Insert(0, new VectorLayerViewModel(layer as VectorLayer));
                    } else if (layer is MyGdalRasterLayer) {
                        _model.Insert(0, new RasterLayerViewModel(layer as MyGdalRasterLayer));
                    }
                }
            }

            lstLayers.ItemsSource = _model;

            if (_model.Count > 0) {
                lstLayers.SelectedIndex = 0;
            }

            MapBackColor = mapControl.mapBox.BackColor;

            backgroundColorPicker.DataContext = this;
        }

        public void Result_is_updated_after_Insert()
        {
            var subject = new ObservableCollection<int>(new [] { 10, 11, 12, 11, 12, 10, 12, 17 });
            var result = subject.ToQueryable().Distinct().ToObservable();
            var eventList = new List<NotifyCollectionChangedEventArgs>();

            result.CollectionChanged += (s, e) => eventList.Add(e);

            Assert.IsInstanceOfType(result, typeof(IQueryableObservableCollection<int>));

            subject.Insert(2, 10);
            EnumerableAssert.AreEqual(result, 10, 11, 12, 17);
            Assert.AreEqual(0, eventList.Count);

            subject.Insert(1, 11);
            EnumerableAssert.AreEqual(result, 10, 11, 12, 17);
            Assert.AreEqual(0, eventList.Count);

            subject.Insert(1, 12);
            EnumerableAssert.AreEqual(result, 10, 12, 11, 17);
            Assert.AreEqual(1, eventList.Count);
            Assert.AreEqual(NotifyCollectionChangedAction.Move, eventList.Last().Action);

            subject.Insert(0, 17);
            EnumerableAssert.AreEqual(result, 17, 10, 12, 11);
            Assert.AreEqual(2, eventList.Count);
            Assert.AreEqual(NotifyCollectionChangedAction.Move, eventList.Last().Action);
        }

        public MainWindowViewModel()
        {
            ValueCollection = new ObservableCollection<int>(_baseSnoozeList);

            ValueCollection.Insert(0, -10);
            ValueCollection.Insert(0,-5);

            TestEventTime = DateTime.Now;
            TestEventTime = TestEventTime.Subtract(new TimeSpan(0, 0, 10, 0));

            ReminderTime = DateTime.Now;

            TestInt = 30;

            TestItems = new ObservableCollection<TestItem>();

            for (int i = 0; i < 5; ++i)
            {
                TestItems.Add(new TestItem
                                  {
                                      Property1 = "Prop " + i + "A",
                                      Property2 = "Prop " + i + "B"
                                  });
            }
        }

        public TabSettingControl()
        {
            AllTabSettings.CollectionChanged += AllTabSettings_CollectionChanged;
            ExtendedTabSettings = new ObservableCollection<object>(AllTabSettings);
            ExtendedTabSettings.Insert(0, new GeneralTabSettings());
            ExtendedTabSettings.Insert(1, new AdvancedTabSettings());
            ExtendedTabSettings.Add(new DummyTabSettings());

            InitializeComponent();

            Context.Set<ISettingsTabNavigator>(this);
        }

        public void Follows_observed_collection()
        {
            var subject = new ObservableCollection<int>(new[] { 11, 12, 13, 14, 15, 16 });

            var observer = new ObserverCollection<int>();

            observer.Observe(subject);
            EnumerableAssert.AreEqual(subject, observer);

            subject.Insert(3, 77);
            EnumerableAssert.AreEqual(subject, observer);

            subject.Add(21);
            EnumerableAssert.AreEqual(subject, observer);

            subject.RemoveAt(0);
            EnumerableAssert.AreEqual(subject, observer);

            subject.RemoveAt(subject.Count - 1);
            EnumerableAssert.AreEqual(subject, observer);

            subject.Move(3, 0);
            EnumerableAssert.AreEqual(subject, observer);

            subject.Move(1, 5);
            EnumerableAssert.AreEqual(subject, observer);

            subject[4] = 777;
            EnumerableAssert.AreEqual(subject, observer);
        }

        public void ObservableCollection_ArgTimes()
        {

            var count = 0;
            var ob = new ObservableCollection<int>() {
            1,2,3,4,5,6,7,8,9
            
            };

            ob.CollectionChanged += (o, e) =>
                {
                    count++;

                };

            ob.Insert(0, -1);

            Assert.AreEqual (count,1);

            ob.Remove(3);

            Assert.AreEqual(count, 2);

        
        }

        public static void setNewParent(Guid itemId, Guid parentId, ObservableCollection<Todo> _Todos)
        {
            var thisItm = _Todos.FirstOrDefault(x=>x.Id==itemId);

            if (parentId!= Guid.Empty)
            {
                var prnt = _Todos.FirstOrDefault(x => x.Id == parentId);
                thisItm.ParentId = prnt.Id;
                thisItm.Wbs = prnt.Wbs + ">";
                int newIdx = _Todos.IndexOf(prnt)+1;
                if (newIdx <= _Todos.Count)
                {
                    _Todos.Remove(thisItm);
                    _Todos.Insert(newIdx, thisItm);
                }
                else
                {
                    _Todos.Remove(thisItm);
                    _Todos.Add(thisItm);
                }
            }
            else
            {
                thisItm.ParentId = Guid.Empty;
                thisItm.Wbs = ">";
            }

            //_Todos[itemIndex] = thisItm;
            updateChildren(thisItm, _Todos);
        }

        public void On_insert()
        {
            var original = new[] { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };

            ObservableCollection<int> subject;
            IReadOnlyList<int> sherlock;
            var changes = new Queue<NotifyCollectionChangedEventArgs>();

            subject = new ObservableCollection<int>(original);
            subject.CollectionChanged += (s, e) => changes.Enqueue(e);

            subject.Insert(3, 777);
            sherlock = subject.Rewind(changes.Dequeue());
            EnumerableAssert.AreEqual(original, sherlock);

            subject = new ObservableCollection<int>(original);
            subject.CollectionChanged += (s, e) => changes.Enqueue(e);

            subject.Insert(0, 777);
            sherlock = subject.Rewind(changes.Dequeue());
            EnumerableAssert.AreEqual(original, sherlock);

            subject = new ObservableCollection<int>(original);
            subject.CollectionChanged += (s, e) => changes.Enqueue(e);

            subject.Insert(8, 777);
            sherlock = subject.Rewind(changes.Dequeue());
            EnumerableAssert.AreEqual(original, sherlock);
        }

        private void HandleCollectionChanges(Client client, NotifyCollectionChangedEventArgs args, ObservableCollection<Interlocutor> actualCollection, ObservableCollection<object> nullCollection)
        {
            if (actualCollection.Count == 0)
            {
                nullCollection.Clear();
                nullCollection.Add(new NullInterlocutor(client));
                return;
            }
            var nullInterlocutor = nullCollection.OfType<NullInterlocutor>().FirstOrDefault();
            if (nullInterlocutor != null)
            {
                nullCollection.Remove(nullInterlocutor);
            }

            if (args.OldItems != null)
            {
                foreach (var oldItem in args.OldItems)
                {
                    nullCollection.Remove(oldItem);
                }
            }

            if (args.NewItems != null)
            {
                foreach (var newItem in args.NewItems)
                {
                    nullCollection.Insert(actualCollection.IndexOf((Interlocutor) newItem), newItem);
                }
            }
        }

        protected override async void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);

            items = new ObservableCollection<SensorData>();
            ItemList.ItemsSource = items;

            // Connect to the service
            var hubConnection = new HubConnection("http://localhost:4734/");

            // Create a proxy to the chat service
            var chat = hubConnection.CreateHubProxy("observableSensorHub");

            // Print the message when it comes in
            //chat.On<SensorData>("broadcast", value =>
            //    Dispatcher.BeginInvoke(new Action(() => items.Insert(0, value))));

            chat.Observe("broadcast")
                .Select(item => JsonConvert.DeserializeObject<SensorData>(item[0].ToString()))
                .Where(item => item.Category == "1")
                .ObserveOnDispatcher()
                .Subscribe(item => items.Insert(0, item));

            // Start the connection
            await hubConnection.Start();

        }

 public AddDialogModelView()
 {
     Users = new ObservableCollection<CredentialUser>();
     Utility.RefreshUsers(Users);
     Users.Insert(0, NewUserCredential);
     User = Users[0];
 }

        async static public Task<ObservableCollection<Comment>> load_comments(string elem)
        {
            Exception exception = null;
            _commentlist = new ObservableCollection<Comment>();
            elem += "/comments";

            try
            {
                var comments = (List<Comment>)await Http_get.get_object(new List<Comment>(), elem);

                foreach (var item in comments)
                    _commentlist.Insert(0, item); // To have the last comment on top
                //_commentlist.Add(item);
                return _commentlist;
            }
            catch (Exception e)
            {
                exception = e;
            }

            if (exception != null)
                await new MessageDialog("Erreur lors de la récupération des commentaires").ShowAsync();
            return null;
           
        }

        public ConnectWindow()
        {
            InitializeComponent();

            try
            {
                IsAvailableServer = ServiceCtrlClass.ServiceIsInstalled("EpgTimer Service") == true ||
                    System.IO.File.Exists(SettingPath.ModulePath.TrimEnd('\\') + "\\EpgTimerSrv.exe") == true;

                btn_edit.Visibility = Visibility.Collapsed;

                ConnectionList = new ObservableCollection<NWPresetItem>(Settings.Instance.NWPreset);
                var nowSet = new NWPresetItem(DefPresetStr, Settings.Instance.NWServerIP, Settings.Instance.NWServerPort, Settings.Instance.NWWaitPort, Settings.Instance.NWMacAdd, Settings.Instance.NWPassword);
                int pos = ConnectionList.ToList().FindIndex(item => item.EqualsTo(nowSet, true));
                if (pos == -1)
                {
                    ConnectionList.Add(nowSet);
                    pos = ConnectionList.Count - 1;
                }
                if (IsAvailableServer == true)
                {
                    ConnectionList.Insert(0, new NWPresetItem("ローカル接続", "", 0, 0, "", new SerializableSecureString()));
                    pos++;
                }
                ConnectionList.Add(new NWPresetItem("<新規登録>", "", 0, 0, "", new SerializableSecureString()));

                listView_List.ItemsSource = ConnectionList;
                if (IsAvailableServer == false)
                {
                    Settings.Instance.NWMode = true;
                }
                listView_List.SelectedIndex = Settings.Instance.NWMode == true ? pos : 0;
            }
            catch { }
        }

 /// <summary>
 /// Get an instance of SecurityPaperFilters and initialize all
 /// </summary>
 public SecurityPaperFilters()
 {
     EntryPointList = new ObservableCollection<EntryPoint>(StaticReferences.GetEntryPoints());
     EntryPointList.Insert(0, new EntryPoint { EntryPointId = 0, Name = Strings.All });
     if (App.CurrentUser.IsInRole(UserRoleEnum.BorderAgent, UserRoleEnum.LOAdmin))
         SelectedEntryPointId = App.CurrentUser.EntryPointId.GetValueOrDefault();
 }

        public Window1()
        {
            //Setup twitter
            //IFluentTwitter twitclient = FluentTwitter.CreateRequest().AuthenticateAs("uid", "pwd");
            //ITwitterStatuses twitStatuses = twitclient.Statuses();

            //generate temperature alerts
            ObservableUsbTemper temperature = new ObservableUsbTemper();

            IObservable<double> ts = temperature.TemperatureStreamFarenheight;
            IObservable<IList<double>> tsSlidingWindow = ts.Buffer(TimeSpan.FromSeconds(5));
            IObservable<double> avgTempOverTime = tsSlidingWindow.Select(buff => buff.Average());
            IObservable<double> tempAlerts = avgTempOverTime.Where(avgtemp => avgtemp < 80);

            // Send to twitter
            IObservable<string> twitterResponses = tempAlerts.Sample(TimeSpan.FromMinutes(1))
                .Select(cold => string.Format("It's cold here. Avg temp is {0:0.00}", cold));

            // now wire-up the UI
            InitializeComponent();
            this.DataContext = this;

            OCFarenheightReadings = new ObservableCollection<double>();
            OCSlidingWindow = new ObservableCollection<IList<double>>();
            OCavgTempOverTime = new ObservableCollection<double>();
            OCtempAlerts = new ObservableCollection<double>();
            OCtwitterResponses = new ObservableCollection<string>();

            OCFarenheightReadings.Insert(ts);
            OCSlidingWindow.Insert(tsSlidingWindow);
            OCavgTempOverTime.Insert(avgTempOverTime);
            OCtempAlerts.Insert(tempAlerts);
            OCtwitterResponses.Insert(twitterResponses);
        }