public override async System.Threading.Tasks.Task Load() { await base.Load(); _itemsSource.AddRange(mockedDataGenerator.GenerateMockedPersonList(0)); BuildAndSetObservable(); }
public void AddRange() { var people = _generator.Take(100).ToList(); _source.AddRange(people); Assert.AreEqual(100, _collection.Count, "Should be 100 items in the collection"); CollectionAssert.AreEquivalent(people, _collection, "Collections should be equivalent"); }
public void AddRange() { var people = Generator.Take(100).ToList(); _source.AddRange(people); _collection.Count.Should().Be(100, "Should be 100 items in the collection"); _collection.ShouldAllBeEquivalentTo(_collection, "Collections should be equivalent"); }
public void PropertyFilter() { var schedulerProvider = new TestSchedulerProvider(); using (var sourceList = new SourceList <Animal>()) using (var sut = new PropertyFilter(sourceList, schedulerProvider)) { //start the scheduler schedulerProvider.TestScheduler.Start(); //add items sourceList.AddRange(_items); sut.Filtered.Count.Should().Be(0); //set to true to include in the result set _items[1].IncludeInResults = true; _items[2].IncludeInResults = true; _items[3].IncludeInResults = true; //progress scheduler schedulerProvider.TestScheduler.Start(); sut.Filtered.Items.ShouldAllBeEquivalentTo(new [] { _items[1], _items[2], _items[3] }); } }
public MainViewModel() { _movieService = new MovieService(); LoadNextPageCommand = ReactiveCommand.CreateFromTask <int, List <ShowDto> >(async _ => { var items = await _movieService.LoadPage(_pageNr); await Task.Delay(1000); return(items); }); LoadNextPageCommand.IsExecuting.BindTo(this, vm => vm.IsBusy); LoadNextPageCommand.Subscribe(shows => { _showsList.AddRange(shows); }); LoadNextPageCommand.Execute(_pageNr).Subscribe(); LoadNextPageCommand.IsExecuting .ToProperty(this, vm => vm.IsLoadingItems, out _isLoadingItems); _showsList .Connect() .ObserveOn(RxApp.MainThreadScheduler) .Sort(SortExpressionComparer <ShowDto> .Ascending(a => a.Id)) .Bind(Shows) .Subscribe(); Shows.ShouldLoadMoreThreshold = 100; Shows.OnLoadMore += OnLoadMore; Shows.OnCanLoadMore += OnCanLoadMore; }
public ConfirmRecoveryWordsViewModel(List <RecoveryWordViewModel> mnemonicWords, KeyManager keyManager) { var confirmationWordsSourceList = new SourceList <RecoveryWordViewModel>(); _isSkipEnable = Services.WalletManager.Network != Network.Main || System.Diagnostics.Debugger.IsAttached; var nextCommandCanExecute = confirmationWordsSourceList .Connect() .ObserveOn(RxApp.MainThreadScheduler) .WhenValueChanged(x => x.IsConfirmed) .Select(_ => confirmationWordsSourceList.Items.All(x => x.IsConfirmed)); EnableBack = true; NextCommand = ReactiveCommand.Create(() => OnNext(keyManager), nextCommandCanExecute); if (_isSkipEnable) { SkipCommand = ReactiveCommand.Create(() => NextCommand.Execute(null)); } CancelCommand = ReactiveCommand.Create(OnCancel); confirmationWordsSourceList .Connect() .ObserveOn(RxApp.MainThreadScheduler) .OnItemAdded(x => x.Reset()) .Sort(SortExpressionComparer <RecoveryWordViewModel> .Ascending(x => x.Index)) .Bind(out _confirmationWords) .Subscribe(); // Select random words to confirm. confirmationWordsSourceList.AddRange(mnemonicWords.OrderBy(_ => new Random().NextDouble()).Take(3)); }
protected override void OnNavigatedTo(bool isInHistory, CompositeDisposable disposables) { base.OnNavigatedTo(isInHistory, disposables); if (!isInHistory) { var pockets = _wallet.Coins.GetPockets(_wallet.ServiceConfiguration.GetMixUntilAnonymitySetValue()).Select(x => new PocketViewModel(x)); _pocketSource.AddRange(pockets); } foreach (var pocket in _pockets) { pocket.IsSelected = false; } if (_pocketSource.Count == 1) { _pocketSource.Items.First().IsSelected = true; Complete(); } else if (_isSilent && _pocketSource.Items.FirstOrDefault(x => x.Labels == CoinPocketHelper.PrivateFundsText) is { } privatePocket&& privatePocket.Coins.TotalAmount() >= _transactionInfo.Amount) { privatePocket.IsSelected = true; Complete(); } }
public SampleViewModel(IMessageService messageService) { this.messageService = messageService; WrittenText = new Subject <object>(); WrittenText.Subscribe(t => { }); ShowMessageCommand = new DelegateCommand(() => messageService.ShowMessage("Saludos, colleiga!")); var people = new List <Person>() { new Person() { Name = "José Manuel", Surname = "Nieto", }, new Person() { Name = "Ana Isabel", Surname = "Meana", }, new Person() { Name = "Bichito", Surname = "LG", } }; ISourceList <object> sourceList = new SourceList <object>(); sourceList.AddRange(people); People = sourceList; }
public void MonitorSelectedItems(MonitorSelectedItemsMode mode) { var initialItems = Enumerable.Range(1, 10) .Select(i => new SelectableItem(i)) .ToArray(); //result should only be true when all items are set to true using (var sourceList = new SourceList <SelectableItem>()) using (var sut = new MonitorSelectedItems(sourceList, mode)) { sourceList.AddRange(initialItems); sut.HasSelection.Should().Be(false); sut.SelectedMessage.Should().Be("Nothing Selected"); initialItems[0].IsSelected = true; sut.HasSelection.Should().Be(true); sut.SelectedMessage.Should().Be("1 item selected"); initialItems[1].IsSelected = true; sut.HasSelection.Should().Be(true); sut.SelectedMessage.Should().Be("2 items selected"); //remove the selected items sourceList.RemoveRange(0, 2); sut.HasSelection.Should().Be(false); sut.SelectedMessage.Should().Be("Nothing Selected"); } }
public void DynamicFilter() { var schedulerProvider = new TestSchedulerProvider(); using (var sourceList = new SourceList <Animal>()) using (var sut = new DynamicFilter(sourceList, schedulerProvider)) { //start the scheduler schedulerProvider.TestScheduler.Start(); //add items sourceList.AddRange(_items); sut.Filtered.Items.ShouldAllBeEquivalentTo(_items); sut.Filtered.Count.Should().Be(_items.Length); //set a filter sut.AnimalFilter = "Dog"; schedulerProvider.TestScheduler.Start(); sut.Filtered.Items.ShouldAllBeEquivalentTo(_items.Where(a => a.Type == "Dog")); sut.Filtered.Count.Should().Be(2); //add a new dog to show it is included in the result set sourceList.Add(new Animal("George", "Dog", AnimalFamily.Mammal)); sut.Filtered.Count.Should().Be(3); //add a new bird to show it is included in the result set sourceList.Add(new Animal("Peter", "Parrot", AnimalFamily.Bird)); sut.Filtered.Count.Should().Be(3); } }
public void AutoRefresh() { var items = Enumerable.Range(1, 100).Select(i => new Person("Person" + i, 1)).ToArray(); //result should only be true when all items are set to true using var list = new SourceList <Person>(); using var results = list.Connect().AutoRefresh(p => p.Age).AsAggregator(); list.AddRange(items); results.Data.Count.Should().Be(100); results.Messages.Count.Should().Be(1); items[0].Age = 10; results.Data.Count.Should().Be(100); results.Messages.Count.Should().Be(2); results.Messages[1].First().Reason.Should().Be(ListChangeReason.Refresh); //remove an item and check no change is fired var toRemove = items[1]; list.Remove(toRemove); results.Data.Count.Should().Be(99); results.Messages.Count.Should().Be(3); toRemove.Age = 100; results.Messages.Count.Should().Be(3); //add it back in and check it updates list.Add(toRemove); results.Messages.Count.Should().Be(4); toRemove.Age = 101; results.Messages.Count.Should().Be(5); results.Messages.Last().First().Reason.Should().Be(ListChangeReason.Refresh); }
public void AutoRefreshGroup() { var items = Enumerable.Range(1, 100) .Select(i => new Person("Person" + i, i)) .ToArray(); //result should only be true when all items are set to true using (var list = new SourceList <Person>()) using (var results = list.Connect() .AutoRefresh(p => p.Age) .GroupOn(p => p.Age % 10) .AsAggregator()) { void CheckContent() { foreach (var grouping in items.GroupBy(p => p.Age % 10)) { var childGroup = results.Data.Items.Single(g => g.GroupKey == grouping.Key); var expected = grouping.OrderBy(p => p.Name); var actual = childGroup.List.Items.OrderBy(p => p.Name); actual.ShouldAllBeEquivalentTo(expected); } } list.AddRange(items); results.Data.Count.Should().Be(10); results.Messages.Count.Should().Be(1); CheckContent(); //move person from group 1 to 2 items[0].Age = items[0].Age + 1; CheckContent(); //change the value and move to a grouping which does not yet exist items[1].Age = -1; results.Data.Count.Should().Be(11); results.Data.Items.Last().GroupKey.Should().Be(-1); results.Data.Items.Last().List.Count.Should().Be(1); results.Data.Items.First().List.Count.Should().Be(9); CheckContent(); //put the value back where it was and check the group was removed items[1].Age = 1; results.Data.Count.Should().Be(10); CheckContent(); var groupOf3 = results.Data.Items.ElementAt(2); IChangeSet <Person> changes = null; groupOf3.List.Connect().Subscribe(c => changes = c); //refresh an item which makes it belong to the same group - should then propagate a refresh items[2].Age = 13; changes.Should().NotBeNull(); changes.Count.Should().Be(1); changes.First().Reason.Should().Be(ListChangeReason.Replace); changes.First().Item.Current.Should().BeSameAs(items[2]); } }
public void Remove() { var tourProviders = new SourceList <TourProvider>(); var allTours = tourProviders.Connect().TransformMany(tourProvider => tourProvider.Tours).AsObservableList(); var tour1_1 = new Tour("Tour 1.1"); var tour2_1 = new Tour("Tour 2.1"); var tour2_2 = new Tour("Tour 2.2"); var tour3_1 = new Tour("Tour 3.1"); var tp1 = new TourProvider("Tour provider 1", new[] { tour1_1 }); var tp2 = new TourProvider("Tour provider 2", new[] { tour2_1, tour2_2 }); var tp3 = new TourProvider("Tour provider 3", null); tourProviders.AddRange(new[] { tp1, tp2, tp3 }); allTours.Items.Should().BeEquivalentTo(tour1_1, tour2_1, tour2_2); tp3.Tours.Add(tour3_1); allTours.Items.Should().BeEquivalentTo(tour1_1, tour2_1, tour2_2, tour3_1); tp2.Tours.Remove(tour2_1); allTours.Items.Should().BeEquivalentTo(tour1_1, tour2_2, tour3_1); tp2.Tours.Add(tour2_1); allTours.Items.Should().BeEquivalentTo(tour1_1, tour2_1, tour2_2, tour3_1); }
public Shop(IEnumerable <Product> products) { _products.AddRange(products); _products.Connect() .Bind(out readOnlyProducts) .Subscribe(); }
public QueryHistoryProvider() { _historySourceList = new SourceList <RawQueryHistory>(); var counter = _historySourceList.CountChanged.Subscribe(i => IsEmpty = i == 0); var limiter = _historySourceList.LimitSizeTo(100).Subscribe(); _historySourceList.AddRange(LoadFileData()); var sharedList = _historySourceList .Connect() .DeferUntilLoaded() .Sort(SortExpressionComparer <RawQueryHistory> .Descending(t => t.LastRunAt)) .ObserveOnDispatcher() .Bind(out _queryHistories) .Subscribe(); var disposable = _queryHistories .ObserveCollectionChanges() .Throttle(TimeSpan.FromSeconds(2)) .Subscribe(pattern => { SaveFileData(_queryHistories); }); _compositeDisposable = new CompositeDisposable(counter, limiter, sharedList, disposable); }
public IObservable <Action> LoadNextMessages( Target target, SourceList <ItemModel> items) { switch (target) { case Chat chat: return(LoadNextMessages(chat, items) .Aggregate(new List <Message>(), (list, m) => { list.Add(m); return list; }) .Select(messages => new Action(() => { var models = messages .Select(_messageModelFactory.CreateMessage) .Reverse() .ToList(); items.AddRange(models); }))); } return(Observable.Empty <Action>()); }
public void PagingListWithVirtualise() { using (var pager = new BehaviorSubject <IVirtualRequest>(new VirtualRequest(0, 0))) using (var sourceList = new SourceList <Animal>()) using (var sut = new PagingListWithVirtualise(sourceList, pager)) { // Add items to source sourceList.AddRange(_items); // Requested 0 items, so no data should be returned sut.Virtualised.Count.Should().Be(0); // Requested 2 items starting at position 0, 2 items expected pager.OnNext(new VirtualRequest(0, 2)); sut.Virtualised.Count.Should().Be(2); // Requested 2 items starting at position 2, 2 items expected pager.OnNext(new VirtualRequest(2, 2)); sut.Virtualised.Count.Should().Be(2); // Requested 5 items starting at position 0, 5 items expected pager.OnNext(new VirtualRequest(0, 5)); sut.Virtualised.Count.Should().Be(5); // Requested 1 item starting at position 5, 1 items expected pager.OnNext(new VirtualRequest(5, 1)); sut.Virtualised.Count.Should().Be(1); } }
public void GroupAndMonitorPropertyChanges() { //create manual grouping so we can guage expectations IEnumerable <SpeciesGroup> ManualGrouping(ISourceList <Species> items) { return(items.Items.GroupBy(i => i.Name[0]).Select(g => new SpeciesGroup(g.Key, g.ToArray()))); } using (var sourceList = new SourceList <Species>()) using (var sut = new GroupAndMonitorPropertyChanges(sourceList)) { //populate with initial data var initialData = new[] { new Species("Ant"), new Species("Ape"), new Species("Bear"), new Species("Boar"), new Species("Cougar") }; sourceList.AddRange(initialData); //Check all data has loaded sut.SpeciesByLetter.Items.SelectMany(g => g.Items).ShouldAllBeEquivalentTo(initialData); sut.SpeciesByLetter.Items.ShouldBeEquivalentTo(ManualGrouping(sourceList)); sut.SpeciesByLetter.Count.Should().Be(3); //change the first letter of the data and the groupings will change initialData[0].Name = "Ánt"; //change the first letter sut.SpeciesByLetter.Count.Should().Be(4); //assert everything sut.SpeciesByLetter.Items.ShouldBeEquivalentTo(ManualGrouping(sourceList)); } }
public MainWindowViewModel() { sourceList = new SourceList <SimpleItem>(); //Filling source list sourceList.AddRange(Enumerable.Range(1, 10).Select(i => new SimpleItem(i))); var viewmodel = sourceList .Connect() //Converting collection into observable change set .Transform(item => new SimpleItemViewModel(item)) //Transforming SimpleItem into SimpleItemViewModel .Publish(); //This method allow to have more than one subscriber var selectedItems = viewmodel .AutoRefresh(item => item.IsSelected) //Subscribing to changes of specific property .Filter(item => item.IsSelected) //Setting predicate .Sort(SortExpressionComparer <SimpleItemViewModel> .Ascending(item => item.Number)) //.ObserveOnDispatcher() .Bind(out _selectedItems) //Converting observable sequence to ReadOnlyObservableCollection .Subscribe(); var notSelectedItems = viewmodel .AutoRefresh(item => item.IsSelected) .Filter(item => !item.IsSelected) .Sort(SortExpressionComparer <SimpleItemViewModel> .Ascending(item => item.Number)) //.ObserveOnDispatcher() .Bind(out _notSelectedItems) .Subscribe(); viewmodel.Connect(); //Receiving source sequence to subscribers }
public void InspectCollectionWithObservable() { var initialItems = Enumerable.Range(1, 10) .Select(i => new SimpleObjectWithObservable(i)) .ToArray(); //result should only be true when all items are set to true using (var sourceList = new SourceList <SimpleObjectWithObservable>()) using (var sut = new InspectCollectionWithObservable(sourceList)) { sourceList.AddRange(initialItems); sut.AllActive.Should().Be(false); //should remain false because initialItems[0].SetIsActive(true); sut.AllActive.Should().Be(false); //set all items to true foreach (var item in initialItems) { item.SetIsActive(true); } sut.AllActive.Should().Be(true); initialItems[0].SetIsActive(false); sut.AllActive.Should().Be(false); sourceList.Clear(); sut.AllActive.Should().Be(false); } }
public void AutoRefreshTransform() { var items = Enumerable.Range(1, 100) .Select(i => new Person("Person" + i, i)) .ToArray(); //result should only be true when all items are set to true using (var list = new SourceList <Person>()) using (var results = list.Connect() .AutoRefresh(p => p.Age) .Transform((p, idx) => new TransformedPerson(p, idx)) .AsAggregator()) { list.AddRange(items); results.Data.Count.Should().Be(100); results.Messages.Count.Should().Be(1); //update an item which did not match the filter and does so after change items[0].Age = 60; results.Messages.Count.Should().Be(2); results.Messages.Last().Refreshes.Should().Be(1); results.Messages.Last().First().Item.Reason.Should().Be(ListChangeReason.Refresh); results.Messages.Last().First().Item.Current.Index.Should().Be(0); items[60].Age = 160; results.Messages.Count.Should().Be(3); results.Messages.Last().Refreshes.Should().Be(1); results.Messages.Last().First().Item.Reason.Should().Be(ListChangeReason.Refresh); results.Messages.Last().First().Item.Current.Index.Should().Be(60); } }
public void StressIt() { var list = new SourceList <ClassA>(); var items = Enumerable.Range(1, 10000) .Select(i => new ClassA { Name = i.ToString(), Child = new ClassB { Age = i } }) .ToArray(); list.AddRange(items); var sw = new Stopwatch(); // var factory = var myObservable = list.Connect() .Do(_ => sw.Start()) .WhenPropertyChanged(a => a.Child.Age, false) .Do(_ => sw.Stop()) .Subscribe(); items[1].Child.Age = -1; Console.WriteLine($"{sw.ElapsedMilliseconds}"); }
public void AutoRefreshDistinct() { var items = Enumerable.Range(1, 100) .Select(i => new Person("Person" + i, i)) .ToArray(); //result should only be true when all items are set to true using (var list = new SourceList <Person>()) using (var results = list.Connect() .AutoRefresh(p => p.Age) .DistinctValues(p => p.Age / 10) .AsAggregator()) { list.AddRange(items); results.Data.Count.Should().Be(11); results.Messages.Count.Should().Be(1); //update an item which did not match the filter and does so after change items[50].Age = 500; results.Data.Count.Should().Be(12); results.Messages.Last().First().Reason.Should().Be(ListChangeReason.Add); results.Messages.Last().First().Item.Current.Should().Be(50); } }
public AggregationViewModel() { var sourceList = new SourceList<AggregationItem>(); sourceList.AddRange(Enumerable.Range(1, 15).Select(i => new AggregationItem(i))); //Load items to display to user and allow them to include items or not var listLoader = sourceList.Connect() .Sort(SortExpressionComparer<AggregationItem>.Ascending(vm => vm.Number)) .ObserveOnDispatcher() .Bind(out _items) .Subscribe(); // share the connection because we are doing multiple aggregations var aggregatable = sourceList.Connect() .FilterOnProperty(vm => vm.IncludeInTotal, vm => vm.IncludeInTotal) .Publish(); //Do a custom aggregation (ToCollection() produces a readonly collection of underlying data) var sumOfOddNumbers = aggregatable.ToCollection() .Select(collection => collection.Where(i => i.Number%2 == 1).Select(ai => ai.Number).Sum()) .Subscribe(sum => SumOfOddNumbers = sum); _cleanUp = new CompositeDisposable(sourceList, listLoader, aggregatable.Count().Subscribe(count => Count = count), aggregatable.Sum(ai => ai.Number).Subscribe(sum => Sum = sum), aggregatable.Avg(ai => ai.Number).Subscribe(average => Avg = Math.Round(average,2)), aggregatable.Minimum(ai => ai.Number).Subscribe(max => Max = max), aggregatable.Maximum(ai => ai.Number).Subscribe(min => Min = min), aggregatable.StdDev(ai => ai.Number).Subscribe(std => StdDev = Math.Round(std, 2)), sumOfOddNumbers, aggregatable.Connect()); }
public void AutoRefreshSelected() { //test added as v6 broke unit test in DynamicData.Snippets var initialItems = Enumerable.Range(1, 10) .Select(i => new SelectableItem(i)) .ToArray(); //result should only be true when all items are set to true using (var sourceList = new SourceList <SelectableItem>()) using (var sut = sourceList.Connect().AutoRefresh().Filter(si => si.IsSelected).AsObservableList()) { sourceList.AddRange(initialItems); sut.Count.Should().Be(0); initialItems[0].IsSelected = true; sut.Count.Should().Be(1); initialItems[1].IsSelected = true; sut.Count.Should().Be(2); //remove the selected items sourceList.RemoveRange(0, 2); sut.Count.Should().Be(0); } }
public void SwitchOnTest() { SourceList <int> one = new SourceList <int>(); SourceList <int> other = new SourceList <int>(); one.AddRange(new[] { 1, 3 }); other.AddRange(new[] { 2, 4 }); using (var switcher = new BehaviorSubject <Unit>(Unit.Default)) using (var aggregate = switcher.Scan(other, (agg, cur) => agg == one ? other : one).Switch().AsAggregator()) { CollectionAssert.AreEqual(new [] { 1, 3 }, aggregate.Data.Items); switcher.OnNext(Unit.Default); CollectionAssert.AreEqual(new [] { 2, 4 }, aggregate.Data.Items); one.Add(5); CollectionAssert.AreEqual(new [] { 2, 4 }, aggregate.Data.Items); switcher.OnNext(Unit.Default); CollectionAssert.AreEqual(new [] { 1, 3, 5 }, aggregate.Data.Items); other.Remove(4); CollectionAssert.AreEqual(new [] { 1, 3, 5 }, aggregate.Data.Items); one.Remove(3); CollectionAssert.AreEqual(new [] { 1, 5 }, aggregate.Data.Items); } }
public void AutoRefreshBatched() { var scheduler = new TestScheduler(); var items = Enumerable.Range(1, 100) .Select(i => new Person("Person" + i, 1)) .ToArray(); //result should only be true when all items are set to true using (var list = new SourceList <Person>()) using (var results = list.Connect().AutoRefresh(p => p.Age, TimeSpan.FromSeconds(1), scheduler: scheduler).AsAggregator()) { list.AddRange(items); results.Data.Count.Should().Be(100); results.Messages.Count.Should().Be(1); //update 50 records items.Skip(50) .ForEach(p => p.Age = p.Age + 1); scheduler.AdvanceBy(TimeSpan.FromSeconds(1).Ticks); //should be another message with 50 refreshes results.Messages.Count.Should().Be(2); results.Messages[1].Refreshes.Should().Be(50); } }
public void Test() { var a0 = new Item("A0"); var i1 = new Item("I1"); var i2 = new Item("I2"); var i3 = new Item("I3"); var obsList = new SourceList <Item>(); obsList.AddRange(new[] { a0, i1, i2, i3 }); var obsListDerived = obsList.Connect() .AutoRefresh(x => x.Name) .Filter(x => x.Name.Contains("I")) .AsObservableList(); obsListDerived.Count.Should().Be(3); obsListDerived.Items.Should().BeEquivalentTo(new[] { i1, i2, i3 }); i1.Name = "X2"; obsListDerived.Count.Should().Be(2); obsListDerived.Items.Should().BeEquivalentTo(new[] { i2, i3 }); a0.Name = "I0"; obsListDerived.Count.Should().Be(3); obsListDerived.Items.Should().BeEquivalentTo(new[] { a0, i2, i3 }); }
public void Aggregations() { using (var dataSource = new SourceList <int>()) using (var sut = new Aggregations(dataSource)) { //check StartWithEmpty() has taken effect sut.Min.Should().NotBeNull(); sut.Max.Should().NotBeNull(); sut.Avg.Should().NotBeNull(); dataSource.AddRange(Enumerable.Range(1, 10)); sut.Min.Should().Be(1); sut.Max.Should().Be(10); sut.Avg.Should().Be(5.5); dataSource.RemoveRange(0, 9); dataSource.Add(100); //items in list = [10,100] sut.Min.Should().Be(10); sut.Max.Should().Be(100); sut.Avg.Should().Be(55); } }
private Task Wizard(bool FSharpVersion) { cancelWizard = new CancellationTokenSource(); // run the study plan wizard in the background on a separate thread (so that the UI remains responsive) return(Task.Run(() => { if (plan.Items.Count() > 0 && StudyPlannerModel.isLegalPlan(plan.Items)) { IEnumerable <StudyPlan> wizard; if (FSharpVersion) { wizard = FSharpSchedulingWizard.TryToImproveSchedule(plan.Items); } else { wizard = CSharpSchedulingWizard.TryToImproveSchedule(plan.Items); } foreach (var betterPlan in wizard) { Debug.Assert(StudyPlannerModel.isLegalPlan(plan.Items)); uiFactory.StartNew(() => { // present each progressively improved study plan as they are discovered plan.Clear(); plan.AddRange(betterPlan); }, cancelWizard.Token); } } }, cancelWizard.Token)); }
public SelectableItemsViewModel() { var sourceList = new SourceList <SimpleItem>(); sourceList.AddRange(Enumerable.Range(1, 10).Select(i => new SimpleItem(i))); //create a shared list of view models var viewModels = sourceList .Connect() .Transform(simpleItem => new SimpleItemViewModel(simpleItem)) .Publish(); //filter on items which are selected and populate into an observable collection var selectedLoader = viewModels .FilterOnProperty(vm => vm.IsSelected, vm => vm.IsSelected) .Sort(SortExpressionComparer <SimpleItemViewModel> .Ascending(vm => vm.Number)) .ObserveOnDispatcher() .Bind(out _selected) .Subscribe(); //filter on items which are not selected and populate into an observable collection var notSelectedLoader = viewModels .FilterOnProperty(vm => vm.IsSelected, vm => !vm.IsSelected) .Sort(SortExpressionComparer <SimpleItemViewModel> .Ascending(vm => vm.Number)) .ObserveOnDispatcher() .Bind(out _notSelected) .Subscribe(); _cleanUp = new CompositeDisposable(sourceList, selectedLoader, notSelectedLoader, viewModels.Connect()); }