C# ObservableCollection.AddRange方法代码示例

        public SettingsVM()
        {
            TemperatureUnitList = Settings.TemperatureUnits;
            HopFormulaList = Settings.HopFormulas;

            //add both unit lists, the metric and american unit, to the listpicker
            WeightUnitList = new ObservableCollection<string>();
            WeightUnitList.AddRange(Settings.MetricWeightUnits);
            WeightUnitList.AddRange(Settings.USWeightUnits);

            //same here for volume units
            VolumeUnitList = new ObservableCollection<string>();
            VolumeUnitList.AddRange(Settings.MetricVolumeUnits);
            VolumeUnitList.AddRange(Settings.USVolumeUnits);

            //selected items
            this._WeightSelection = Settings.WeightUnit;
            this._VolumeSelection = Settings.VolumeUnit;
            this._TemperatureSelection = Settings.TemperatureUnit;
            this._HopFormulaSelection = Settings.HopFormula;

            RaisePropertyChanged("WeightSelection");
            RaisePropertyChanged("TemperatureSelection");
            RaisePropertyChanged("VolumeSelection");
            RaisePropertyChanged("HopFormula");
        }

        public LeagueItemViewModel(GameCore core)
            : base(core)
        {
            Cities = new ObservableCollection<City>();
            TeamViewModels = new ObservableCollection<TeamViewModel>();
            GenerateRandomTeamsViewModel = new GenerateRandomTeamsViewModel(core);
            Reputation = 200;

            GenerateRandomTeamsTogglePopup = new RelayCommand(() =>
            {
                TogglePopup();
            });

            GenerateRandomTeams = new RelayCommand(() =>
            {
                var teams = GenerateRandomTeamsViewModel.GenerateTeams();

                TeamViewModels.Clear();
                TeamViewModels.AddRange(teams.Select(team => team.ToViewModel(core)));
                TeamViewModels.ForEach(vm => vm.Changed += Changed);

                NotifyPropertyChanged("TeamListViewVisibility");
                NotifyPropertyChanged("GenerateRandomTeamsButtonVisibility");
                TogglePopup();
            });

            Reload(core);
        }

        public CreateBranchWindowVM(ControlConstructSchemeVM controlConstructScheme, IfThenElse ifThenElse)
        {
            this.controlConstructScheme = controlConstructScheme;

            questionConstructs = new ObservableCollection<QuestionConstructVM>();
            questionConstructs.AddRange(controlConstructScheme.QuestionConstructs);

            thenConstructs = new ObservableCollection<ConstructVM>();
            thenConstructs.AddRange(controlConstructScheme.ThenConstructs);

            if (ifThenElse == null)
            {
                //新規作成の場合

                TargetQuestionConstruct = controlConstructScheme.SelectedConstruct as QuestionConstructVM;
                branches = new ObservableCollection<BranchVM>();
                //IF～THENを追加
                BranchVM ifBranch = new BranchVM(BranchVM.TYPE_IF_CODE)
                {
                    Parent = this,
                    No = 1,
                };
                ifBranch.Init();
                branches.Add(ifBranch);
            }
            else
            {
                // 編集の場合

                TargetQuestionConstruct = EDOUtils.Find(controlConstructScheme.QuestionConstructs, ifThenElse.IfCondition.QuestionId);
                branches = SequenceUtils.CreateBranches(ifThenElse, this);
            }
        }

        public void ShouldAddWrapperItemsInCorrectPositionFromConstructor()
        {
            var list = new List<string> { "item1", "Clown", "item1", "Zebra", "apple", "item1", "apple" };

            var collectionA = new ObservableCollection<string>();
            collectionA.AddRange(list);

            collectionA[0].ShouldBe("item1");
            collectionA[1].ShouldBe("Clown");
            collectionA[2].ShouldBe("item1");
            collectionA[3].ShouldBe("Zebra");
            collectionA[4].ShouldBe("apple");
            collectionA[5].ShouldBe("item1");
            collectionA[6].ShouldBe("apple");

            var wrapper = new ObservableCollectionWrapper<string, StringWrapper>(collectionA, item => new StringWrapper(item));
            wrapper.Count.ShouldBe(7);

            wrapper[0].Source.ShouldBe(list[0]);
            wrapper[1].Source.ShouldBe(list[1]);
            wrapper[2].Source.ShouldBe(list[2]);
            wrapper[3].Source.ShouldBe(list[3]);
            wrapper[4].Source.ShouldBe(list[4]);
            wrapper[5].Source.ShouldBe(list[5]);
            wrapper[6].Source.ShouldBe(list[6]);
        }

		void ReadRecentPackages()
		{
			IReadOnlyList<RecentPackageInfo> savedRecentPackages = properties.GetList<RecentPackageInfo>(RecentPackagesPropertyName);
			
			recentPackages = new ObservableCollection<RecentPackageInfo>();
			recentPackages.AddRange(savedRecentPackages);
			recentPackages.CollectionChanged += RecentPackagesCollectionChanged;
		}

        public AirportsViewModel(IGetAirports airportsService, IStoreObjects objectStore)
        {
            _objectStore = objectStore;
            Airports = new ObservableCollection<Airport>();
            Airports.Add(Airport.Nearest);
            Airports.AddRange(airportsService.GetNorwegianAirports());

            SaveCommand = new RelayCommand(OnSave);
            LoadSelectedAirportFromDisk();
        }

		public ApplicationListViewModel() {
			var remoteServer = Properties.Settings.Default.RemoteAppServer;
			_applicationManager = new IisApplicationManager(remoteServer);
			ApplicationList = new ObservableCollection<ApplicationViewModel>();
			ApplicationQueue = new ObservableCollection<ApplicationViewModel>();
#if DESIGN
			ApplicationList.AddRange(TestUtils.CreateVms(20));
			ApplicationQueue.AddRange(TestUtils.CreateVms(20, new List<AppState> { AppState.Deleting, AppState.ToDelete, AppState.DeleteError }));
#endif
#if ASYNC_TEST
			ApplicationList.AddRange(TestUtils.CreateVms(20));
#endif
			DeleteApplicationCmd = new DelegateCommand<ApplicationViewModel>(DeleteApplication);
			UndoDeleteApplicationCmd = new DelegateCommand<ApplicationViewModel>(UndoDeleteApplication);
			GetDeleteApplicationInfoCmd = new DelegateCommand<ApplicationViewModel>(GetDeleteApplicationInfo);
			BrowseApplicationCmd = new DelegateCommand<ApplicationViewModel>(BrowseApplication);
			ScanApplicationsCmd = DelegateCommand.FromAsyncHandler(ScanApplications);
			InitObservers();
			SubscribeOnApplicationQueue();
		}

        public void TestSetup()
        {
            item1 = new Model { Name = "1" };
            item2 = new Model { Name = "2" };
            item3 = new Model { Name = "3" };
            item4 = new Model { Name = "4" };
            item5 = new Model { Name = "5" };
            collection = new ObservableCollection<Model>();
            collection.AddRange(item1, item2, item3, item4, item5);

            eventBatcher = new CollectionChangedEventBatch<Model>(collection);
        }

        public void ShouldAddRange()
        {
            var collection = new ObservableCollection<int>();
            var range = new[] { 1, 2, 3, 4, 5, 6 };
            collection.AddRange(range);
            collection.Count.ShouldBe(6);

            collection = new ObservableCollection<int> { 9 };
            collection.AddRange(range);
            collection[0].ShouldBe(9);
            collection[1].ShouldBe(1);
        }

        public static ObservableCollection<Child> SearchArena()
        {
            var result = new ObservableCollection<Child>();

            EnterToBigArenaResponse response = new EnterToBigArenaService().ExecuteSerialize<EnterToBigArenaResponse>();

            if (response != null && response.success)
            {
                result.AddRange(response.children.Where(x => x.arenaStatus == 1));
            }

            return result;
        }

        public void SumAggregatorCollectionChangeCausesRefresh()
        {
            var numbers = new ObservableCollection<object>();
            numbers.AddRange(1, 2, 4);
            var aggregator = numbers.AsBindable<object, int>().Sum();
            var eventCatcher = new PropertyEventMonitor(aggregator);
            Assert.AreEqual(1 + 2 + 4, aggregator.Current);
            Assert.AreEqual(1, eventCatcher.Count);

            // Test an Add
            numbers.Add(8);
            Assert.AreEqual(1 + 2 + 4 + 8, aggregator.Current);
            Assert.AreEqual(2, eventCatcher.Count);

            // Test a Remove
            numbers.RemoveAt(0);
            Assert.AreEqual(2 + 4 + 8, aggregator.Current);
            Assert.AreEqual(3, eventCatcher.Count);

            // Test a Replace
            numbers[0] = 4;
            Assert.AreEqual(4 + 4 + 8, aggregator.Current);
            Assert.AreEqual(4, eventCatcher.Count);

            // Test an AddRange
            numbers.AddRange(4, 5);
            Assert.AreEqual(4 + 4 + 8 + 4 + 5, aggregator.Current);
            Assert.AreEqual(5, eventCatcher.Count);

            // Test a replace with the same value - no events should be raised
            numbers[0] = numbers[0];
            Assert.AreEqual(4 + 4 + 8 + 4 + 5, aggregator.Current);
            Assert.AreEqual(5, eventCatcher.Count);

            // Test an add with 0
            numbers.Add(0);
            Assert.AreEqual(4 + 4 + 8 + 4 + 5, aggregator.Current);
            Assert.AreEqual(5, eventCatcher.Count);
        }

 public static ObservableCollection<BranchVM> CreateBranches(IfThenElse ifThenElse, CreateBranchWindowVM window)
 {
     ObservableCollection<BranchVM> branches = new ObservableCollection<BranchVM>();
     BranchVM ifBranch = CreateIfBranch(ifThenElse, window);
     branches.Add(ifBranch);
     List<BranchVM> elseIfBranches = CreateElseIfBranches(ifThenElse, window);
     branches.AddRange(elseIfBranches);
     BranchVM elseBranch = CreateElseBranch(ifThenElse, window);
     if (elseBranch != null)
     {
         branches.Add(elseBranch);
     }
     return branches;
 }

		private void GenerateAppointments(IDateSpan dateSpan)
		{
			ObservableCollection<Appointment> newSource = new ObservableCollection<Appointment>();

			newSource.AddRange(
				from i in Enumerable.Range(0, (dateSpan.End - dateSpan.Start).Days * 24)
				select new Appointment()
				{
					Subject = "Appointment" + i + " " + dateSpan.Start.AddHours(i).ToShortDateString(),
					Start = dateSpan.Start.AddHours(i),
					End = dateSpan.Start.AddHours(i + 1),
				});

			this.Appointments = newSource;
		}

 public static ObservableCollection<Move> AllAvoidAttackMoves()
 {
     ObservableCollection<Piece> attackablePieces = new ObservableCollection<Piece>();
     foreach (Move move in This.Game.OppositePlayer.AllMoves())
     {
         if (move.EndPosition.Piece != null && !attackablePieces.Contains(move.EndPosition.Piece))
             attackablePieces.Add(move.EndPosition.Piece);
     }
     ObservableCollection<Move> possible = new ObservableCollection<Move>();
     foreach (Piece piece in attackablePieces)
     {
         possible.AddRange<Move>(piece.LegalMoves);
     }
     return possible;
 }

 void CustomerServiceClient_GetOrdersByCriteriaCompleted(object sender, GetOrdersByCriteriaCompletedEventArgs e)
 {
     try
     {
         Orders = new ObservableCollection<OrderListDTO>();
         Orders.AddRange(e.Result.Orders);
     }
     catch (Exception)
     {
         
         throw;
     }
     
     this.RaisePropertyChanged(ord=> ord.Orders);
     //InvokePropertyChanged(new PropertyChangedEventArgs("Orders"));
     _isLoaded = true;
 }