public LoginRouteViewModel(IScreen hostScreen) { HostScreen = hostScreen; var authentication = new Authentication(); var canLogin = this.WhenAny(x => x.LoginName, x => x.Password, (l, p) => !String.IsNullOrWhiteSpace(l.Value) && !String.IsNullOrWhiteSpace(p.Value)); LoginCommand = new ReactiveCommand(canLogin); var loggedIn = LoginCommand.RegisterAsync(_ => Observable.Start(() => { var authenticationResult = authentication.AuthenticateAsync(LoginName, Password). Result; return authenticationResult == AuthenticationResult.Authenticated ? "Přihlášen" : "Nepřihlášen"; })); loggedIn.Subscribe(s => { if (s == "Přihlášen") HostScreen.Router.Navigate.Execute(new PersonListViewModel(HostScreen)); }); message = new ObservableAsPropertyHelper<string>(loggedIn, s => raisePropertyChanged("Message")); }
public BudgetsViewModel(IBudgetService budgetService, INavigationService navigationService, IBudgetSynchronizationService budgetSynchronizationService) { this._budgetService = budgetService; this._navigationService = navigationService; this._budgetSynchronizationService = budgetSynchronizationService; var canOpenBudget = this.WhenAny(f => f.SelectedBudget, budget => budget.Value != null); this.OpenBudget = ReactiveCommand.CreateAsyncTask(canOpenBudget, async _ => { await this._budgetSynchronizationService.SynchronizeBudgetInBackground(this.SelectedBudget); this._navigationService.NavigateToViewModel<BudgetsViewModel>(); }); this.ReloadBudgets = ReactiveCommand.CreateAsyncTask(async _ => { IReadOnlyCollection<Budget> budgets = await this._budgetService.GetBudgetsAsync(); var result = new ReactiveObservableCollection<Budget>(); result.AddRange(budgets); return result; }); this.ReloadBudgets.ToProperty(this, f => f.Budgets, out this._budgetsHelper); }
/// <summary> /// Initializes a new instance of the <see cref="CoreEntityVM"/> class. /// </summary> protected CoreEntityVM() { #region Register Commands //Can save or discard when context has changes and is not submitting var canSaveDiscardCommand = DataManager.DomainContextHasChangesObservable.CombineLatest(DataManager.DomainContextIsSubmittingObservable, (hasChanges, isSubmitting) => hasChanges && !isSubmitting); SaveCommand = new ReactiveCommand(canSaveDiscardCommand); SaveCommand.ObserveOnDispatcher().Subscribe(param => { if (!BeforeSaveCommand()) return; DataManager.EnqueueSubmitOperation(OnSave); }); DiscardCommand = new ReactiveCommand(canSaveDiscardCommand); DiscardCommand.ObserveOnDispatcher().Subscribe(param => { if (!BeforeDiscardCommand()) return; DomainContext.RejectChanges(); AfterDiscard(); DiscardSubject.OnNext(true); }); #endregion }
void SetConfigurationMenu(MainWindowViewModel viewModel) { ConfigurationContextMenu.Items.Clear(); foreach (var item in viewModel.Configrations) { ConfigurationContextMenu.Items.Add(new MenuItem { FontSize = 12, Header = item.Item1, Command = item.Item2 }); } ConfigurationContextMenu.Items.Add(new Separator()); var saveCommand = new ReactiveCommand(); saveCommand.Subscribe(_ => { var dialog = new Microsoft.Win32.SaveFileDialog(); dialog.FilterIndex = 1; dialog.Filter = "JSON Configuration|*.json"; dialog.InitialDirectory = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "configuration"); if (dialog.ShowDialog() == true) { var fName = dialog.FileName; if (!fName.EndsWith(".json")) fName = fName + ".json"; viewModel.SaveCurrentConfiguration(fName); viewModel.LoadConfigurations(); SetConfigurationMenu(viewModel); // reset } }); ConfigurationContextMenu.Items.Add(new MenuItem { FontSize = 12, Header = "Save...", Command = saveCommand }); }
public RepositoryOutlinerVm(RepositoryVm repos) : base(string.Empty, RepositoryOutlinerItemType.Root, null, repos, null) { Debug.Assert(repos != null); _repos = repos; SelectedItem = new ReactiveProperty<RepositoryOutlinerItemVm>() .AddTo(MultipleDisposable); // 各項目のルートノードを配置する _localBranch = new RepositoryOutlinerItemVm("Local", RepositoryOutlinerItemType.LocalBranchRoot, null, repos, this) .AddTo(MultipleDisposable); _remoteBranch = new RepositoryOutlinerItemVm("Remote", RepositoryOutlinerItemType.RemoteBranchRoot, null, repos, this) .AddTo(MultipleDisposable); Children.AddOnScheduler(_localBranch); Children.AddOnScheduler(_remoteBranch); UpdateBranchNodes(_localBranch, repos.LocalBranches, false); UpdateBranchNodes(_remoteBranch, repos.RemoteBranches, true); repos.LocalBranches.CollectionChangedAsObservable() .Subscribe(_ => UpdateBranchNodes(_localBranch, repos.LocalBranches, false)) .AddTo(MultipleDisposable); repos.RemoteBranches.CollectionChangedAsObservable() .Subscribe(_ => UpdateBranchNodes(_remoteBranch, repos.RemoteBranches, true)) .AddTo(MultipleDisposable); SwitchBranchCommand = new ReactiveCommand().AddTo(MultipleDisposable); SwitchBranchCommand.Subscribe(_ => SwitchBranch()).AddTo(MultipleDisposable); }
public IndexViewModel(IRepository repo) { this.repo = repo; this.refreshCommand = ReactiveCommand.Create(); this.repositoryStatus = this.refreshCommand.Select(u => { return repo.RetrieveStatus(new StatusOptions() { Show = StatusShowOption.IndexAndWorkDir }); }).ToProperty(this, vm => vm.RepositoryStatus); this.statusEntries = this .WhenAny(vm => vm.RepositoryStatus, change => { var status = change.GetValue(); return status.CreateDerivedCollection(s => s, null, null, null, this.refreshCommand); }).ToProperty(this, vm => vm.StatusEntries); var resetSignal = this.WhenAny(vm => vm.StatusEntries, change => { return 0; }); var allEntries = this.WhenAny(vm => vm.StatusEntries, change => change.GetValue()); this.unstagedEntries = allEntries.Select(s => { return s.CreateDerivedCollection(i => i, i => Unstaged(i.State), null, resetSignal); }).ToProperty(this, vm => vm.UnstagedEntries); this.stagedEntries = allEntries.Select(s => { return s.CreateDerivedCollection(i => i, i => Staged(i.State), null, resetSignal); }).ToProperty(this, vm => vm.StagedEntries); }
public MainWindowViewModel(ISentenceFactory sentenceFactory) { _sentenceFactory = sentenceFactory; CreateSentenceCommand = new ReactiveCommand(this.WhenAny(x => x.NewSentence, x => !string.IsNullOrEmpty(x.Value))); CreateSentenceCommand.Subscribe(_ => CreateSentence()); }
public MainWindowViewModel() { var whenAnyColorChanges = this.WhenAny(x => x.Red, x => x.Green, x => x.Blue, (r, g, b) => Tuple.Create(r.Value, g.Value, b.Value)) .Select(intsToColor); _FinalColor = whenAnyColorChanges .Where(x => x != null) .Select(x => x.Value) .ToProperty(this, x => x.FinalColor); Ok = ReactiveCommand.Create(whenAnyColorChanges.Select(x => x != null)); _Images = this.WhenAny(x => x.FinalColor, x => x.Value) .Throttle(TimeSpan.FromSeconds(0.7), RxApp.MainThreadScheduler) .Do(_ => IsBusy = true) .Select(x => imagesForColor(x)) .Switch() .SelectMany(imageListToImages) .ObserveOn(RxApp.MainThreadScheduler) .Do(_ => IsBusy = false) .ToProperty(this, x => x.Images); _Images.ThrownExceptions.Subscribe(ex => this.Log().WarnException("Can't load images", ex)); }
public ViewModel2() { SearchResults = new ReactiveList<FlickrPhoto>(); var canSearch = this.WhenAny(x => x.SearchTerm, x => !String.IsNullOrWhiteSpace(x.Value)); Search = ReactiveCommand.CreateAsyncTask(canSearch, async _ => { return await GetSearchResultFromBing(this.SearchTerm); }); LoadMoreItems = ReactiveCommand.CreateAsyncTask(canSearch, async x => { return await LoadMore((int)x); }); Search.Subscribe(results => { SearchResults.Clear(); foreach (var item in results) { SearchResults.Add(item); } }); LoadMoreItems.Subscribe(results => { foreach (var item in results) { SearchResults.Add(item); } }); Search.ThrownExceptions.Subscribe(ex => { UserError.Throw("Potential network connectivity Error", ex); }); LoadMoreItems.ThrownExceptions.Subscribe(ex => { UserError.Throw("Problem when downloading additional items", ex); }); this.WhenAnyValue(x => x.SearchTerm) .Throttle(TimeSpan.FromSeconds(1), RxApp.MainThreadScheduler) .InvokeCommand(this, x => x.Search); //SearchTerm = "british cat"; }
public void ReactiveCommandAllFlow() { var testScheduler = new TestScheduler(); var @null = (object)null; var recorder1 = testScheduler.CreateObserver<object>(); var recorder2 = testScheduler.CreateObserver<object>(); var cmd = new ReactiveCommand(); cmd.Subscribe(recorder1); cmd.Subscribe(recorder2); cmd.CanExecute().Is(true); cmd.Execute(); testScheduler.AdvanceBy(10); cmd.Execute(); testScheduler.AdvanceBy(10); cmd.Execute(); testScheduler.AdvanceBy(10); cmd.Dispose(); cmd.CanExecute().Is(false); cmd.Dispose(); // dispose again recorder1.Messages.Is( OnNext(0, @null), OnNext(10, @null), OnNext(20, @null), OnCompleted<object>(30)); recorder2.Messages.Is( OnNext(0, @null), OnNext(10, @null), OnNext(20, @null), OnCompleted<object>(30)); }
public LogInViewModel(IScreen host, IGitHubClient ghClient) { this.HostScreen = host; this.GHClient = ghClient; // Only allow a submit when the user name is valid var validStuffTyped = this.WhenAny(x => x.UserName, x => x.Password, (user, pass) => !string.IsNullOrWhiteSpace(user.Value) && !string.IsNullOrWhiteSpace(pass.Value)); Submit = new ReactiveCommand(validStuffTyped); //todo: better make a cancel or else you'll get very mad! //Submit.Subscribe(_ => //{ // GHClient.Authorization.Create(); // //try // //{ // // //if (user != null) // // //{ // // // Insert the user into the cache // // BlobCache.UserAccount.InsertObject<User>("MyUser", user); // // //} // //} // //catch (AuthorizationException authEx) // //{ // // Debug.Print("CRAP!"); // // Debug.Print(authEx.Message); // // Debug.Print(authEx.StackTrace); // //} //}); MessageBus.Current.RegisterMessageSource(Submit); }
public InsertGistViewModel() { //var client = new GitHubClient() { Username = "******", Password = "******" }; var privateImage = new BitmapImage(new Uri(@"pack://*****:*****@"pack://application:,,,/data/public.png")); _PublicPrivateIcon = this.WhenAny(x => x.IsPrivateGist, x => x.Value) .Select(x => x ? privateImage : publicImage) .ToProperty(this, x => x.PublicPrivateIcon); CreateGist = new ReactiveAsyncCommand(); CreateGist.RegisterAsyncObservable(_ => client.CreateGist(SelectionText, !IsPrivateGist)) .Select(x => x.html_url) .BindTo(this, x => x.LastGistUrl); CopyToClipboard = new ReactiveCommand( this.WhenAny(x => x.LastGistUrl, x => !String.IsNullOrWhiteSpace(x.Value))); CopyToClipboard.Subscribe(_ => Clipboard.SetText(LastGistUrl)); this.WhenAny(x => x.SelectionText, x => x.Value) .Where(_ => LastGistUrl != null) .Subscribe(_ => LastGistUrl = null); }
public PersonListViewModel(IScreen hostScreen, IPersonRepository personRepository = null) { HostScreen = hostScreen; personRepository = personRepository ?? new PersonRepository(); Persons = new ReactiveList<PersonItemViewModel>(); NewPersonCommand = new ReactiveCommand(null); NewPersonCommand.RegisterAsyncAction(_ => { }).Subscribe(_ => HostScreen.Router.Navigate.Execute(new PersonAddViewModel(HostScreen))); RefreshCommand = new ReactiveCommand(null); var refresh = RefreshCommand.RegisterAsync<List<Person>>(_ => Observable.Start(() => personRepository.RetrievePersonsAsync(). Result)); refresh.Subscribe(list => { using (Persons.SuppressChangeNotifications()) { Persons.Clear(); Persons.AddRange(personRepository.RetrievePersonsAsync(). Result.Select(d => new PersonItemViewModel(d.FirstName, d.LastName, d.Age))); } }); MessageBus.Current.Listen<Person>(). Subscribe(p => { personRepository.AddPerson(p); RefreshCommand.Execute(null); }); }
public SerializationViewModel() { // Observable sequence to ObservableCollection Items = Observable.Interval(TimeSpan.FromSeconds(1)) .Take(30) .ToReactiveCollection(); IsChecked = new ReactiveProperty<bool>(); SelectedIndex = new ReactiveProperty<int>(); Text = new ReactiveProperty<string>(); SliderPosition = new ReactiveProperty<int>(); var serializedString = new ReactiveProperty<string>(mode: ReactivePropertyMode.RaiseLatestValueOnSubscribe); Serialize = serializedString.Select(x => x == null).ToReactiveCommand(); Deserialize = serializedString.Select(x => x != null).ToReactiveCommand(); // Click Serialize Button Serialize.Subscribe(_ => { // Serialize ViewModel's all ReactiveProperty Values. // return value is string that Serialize by DataContractSerializer. serializedString.Value = SerializeHelper.PackReactivePropertyValue(this); // this = ViewModel }); // Click Deserialize Button Deserialize.Subscribe(_ => { // Deserialize to target ViewModel. // Deseirlization order is same as DataContract. // Can control DataMemberAttribute's Order Property. // more info see http://msdn.microsoft.com/en-us/library/ms729813.aspx SerializeHelper.UnpackReactivePropertyValue(this, serializedString.Value); serializedString.Value = null; // push to command canExecute }); }
public OpenFileTabContentViewModel(IDialogService dialogService) { this.dialogService = dialogService; openFileCommand = ReactiveCommand.Create(); openFileCommand.Subscribe(_ => OpenFile()); }
public MainViewModel() { _informationEngine = new InformationEngine(); _sessionViewModels = _informationEngine.Sessions.CreateDerivedCollection(x => new SessionViewModel(x) as ISessionViewModel); ((IEditableCollectionView) (CollectionViewSource.GetDefaultView(_sessionViewModels))) .NewItemPlaceholderPosition = NewItemPlaceholderPosition.AtEnd; _showInitializationErrorMessage = () => MessageBox.Show( "Bei der Initialisierung des Receivers ist ein Fehler aufgetreten.\n" + "Bitte schließen Sie die Session und starten den Receiver neu.", "Fehler"); _showCloseSessionErrorMessage = () => MessageBox.Show( "Beim Schließen der Session trat ein Fehler auf.", "Fehler"); StartNewSessionCommand = new ReactiveCommand(); StartNewSessionCommand.Subscribe(_ => StartNewSession()); InitializeReceiverCommand = new ReactiveAsyncCommand(); InitializeReceiverCommand.RegisterAsyncAction(x => InitializeReceiver((Tuple<Guid, IReceiver>) x)); InitializeReceiverCommand.ThrownExceptions.Subscribe( ex => _showInitializationErrorMessage()); CloseSessionCommand = new ReactiveCommand(); CloseSessionCommand.Subscribe(x => CloseSession((ISessionViewModel) x)); CloseSessionCommand.ThrownExceptions.Subscribe(ex => _showCloseSessionErrorMessage()); }
public OpenCacheViewModel(IScreen hostScreen, IAppState appState) { HostScreen = hostScreen; var isCachePathValid = this.WhenAny( x => x.CachePath, x => x.OpenAsEncryptedCache, x => x.OpenAsSqlite3Cache, (cp, _, sql) => new { Path = cp.Value, Sqlite3 = sql.Value }) .Throttle(TimeSpan.FromMilliseconds(250), RxApp.MainThreadScheduler) .Select(x => x.Sqlite3 ? File.Exists(x.Path) : Directory.Exists(x.Path)); OpenCache = new ReactiveCommand(isCachePathValid); OpenCache.SelectMany(_ => openAkavacheCache(CachePath, OpenAsEncryptedCache, OpenAsSqlite3Cache)) .LoggedCatch(this, Observable.Return<IBlobCache>(null)) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => { if (x == null) { UserError.Throw("Couldn't open this cache"); return; } appState.CurrentCache = x; hostScreen.Router.Navigate.Execute(new CacheViewModel(hostScreen, appState)); }); }
public MainVM() { var bobbyJoe = new Person("Bobby Joe", new[] { new Pet("Fluffy") }); var bob = new Person("Bob", new[] { bobbyJoe }); var littleJoe = new Person("Little Joe"); var joe = new Person("Joe", new[] { littleJoe }); Family = new ReactiveList<TreeItem> { bob, joe }; _addPerson = ReactiveCommand.Create(); _addPerson.Subscribe(_ => { if (SelectedItem == null) return; var p = new Person(NewName); SelectedItem.AddChild(p); p.IsSelected = true; p.ExpandPath(); }); _addPet = ReactiveCommand.Create(); _addPet.Subscribe(_ => { if (SelectedItem == null) return; var p = new Pet(PetName); SelectedItem.AddChild(p); p.IsSelected = true; p.ExpandPath(); }); _collapse = ReactiveCommand.Create(); _collapse.Subscribe(_ => { SelectedItem?.CollapsePath(); }); }
public TwoFactorViewModel(IScreen host) { HostScreen = host; var codeHasBeenInput = this.WhenAny(x => x.Code, code => !string.IsNullOrWhiteSpace(code.Value)); Submit = new ReactiveCommand(codeHasBeenInput); }
public MyPageViewModel(ITicketService ticketService, ITicketMapper mapper) { _ticketService = ticketService; _mapper = mapper; LoadTickets = new ReactiveAsyncCommand(null, 1, RxApp.DeferredScheduler); LoadTickets.RegisterAsyncFunction(x => loadTickets()) .ToProperty(this, x => x.Tickets); Observable.Interval(TimeSpan.FromSeconds(10), RxApp.DeferredScheduler) .InvokeCommand(LoadTickets); LoadTickets.Execute(null); _redmineBaseUrl = ConfigurationManager.AppSettings["Redmine.BaseRedmineUrl"]; SortBy = new List<SortByModel>() { new SortByModel("Project", c => c.Project), new SortByModel("Due date", c=> c.DueDate), new SortByModel("Priority", c => c.Priority), }; SortByCommand = new ReactiveCommand(this.WhenAny(c => c.Tickets, ((tickets) => tickets.Value != null && tickets.Value.Count > 0))); SortByCommand.Subscribe(c => sortTickets((SortByModel)c)); }
public OpenDatabaseViewModel( INavigationService navigationService, IDatabaseInfoRepository databaseInfoRepository, ICanSHA256Hash hasher, IDialogService dialogService, IPWDatabaseDataSource databaseSource, ICache cache) { _cache = cache; _databaseSource = databaseSource; _dialogService = dialogService; _databaseInfoRepository = databaseInfoRepository; _hasher = hasher; _navigationService = navigationService; var canHitOpen = this.WhenAny( vm => vm.Password, vm => vm.KeyFileName, (p, k) => !string.IsNullOrEmpty(p.Value) || !string.IsNullOrEmpty(k.Value)); OpenCommand = new ReactiveCommand(canHitOpen); OpenCommand.Subscribe(OpenDatabase); GetKeyFileCommand = new ReactiveCommand(); GetKeyFileCommand.Subscribe(GetKeyFile); ClearKeyFileCommand = new ReactiveCommand(); ClearKeyFileCommand.Subscribe(ClearKeyFile); IObservable<string> keyFileNameChanged = this.WhenAny(vm => vm.KeyFileName, kf => kf.Value); keyFileNameChanged.Subscribe(v => ClearKeyFileButtonIsVisible = !string.IsNullOrWhiteSpace(v)); keyFileNameChanged.Subscribe(v => GetKeyFileButtonIsVisible = string.IsNullOrWhiteSpace(v)); }
public SelectedToolViewModel(UIView toolboxView, AvailableToolsContainerViewController container, MeetingViewModel meeting, IReactiveList<IToolViewModel> selectedTools, NavigationPaneViewModel navigationPane) { SelectedTools = selectedTools; IsEmpty = SelectedTools.Count == 0; SelectedTools.Changed.ObserveOn(RxApp.MainThreadScheduler) .Subscribe(p => { IsEmpty = SelectedTools.Count == 0; }); var showAvailableToolsCommand = new ReactiveCommand(); showAvailableToolsCommand.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ => { UIView.BeginAnimations(null); UIView.SetAnimationDuration(0.25); toolboxView.Alpha = 1.0f; UIView.CommitAnimations(); }); container.CloseToolboxRequested += (s, e) => { UIView.BeginAnimations(null); UIView.SetAnimationDuration(0.25); toolboxView.Alpha = 0.0f; UIView.CommitAnimations(); }; ShowAvailableToolsCommand = showAvailableToolsCommand; navigationPane.ShowToolLibraryAction = () => ShowAvailableToolsCommand.Execute(null); var setActiveToolsCommand = new ReactiveCommand(); setActiveToolsCommand.ObserveOn(RxApp.MainThreadScheduler) .Subscribe(tool => meeting.ActiveTool = (IToolViewModel)tool); SetActiveToolCommand = setActiveToolsCommand; }
public CreateActivityViewModel() { int result = 0; var canSave = this.WhenAny( x => x.Name, x => x.ExpectedEffort, (n, e) => !string.IsNullOrWhiteSpace(n.Value) && int.TryParse(e.Value, out result)); SaveCommand = new ReactiveCommand(canSave, DispatcherScheduler.Instance); SaveCommand.Subscribe(o => Save()); var prototypeActivity = this.Changed .Where(c => c.PropertyName == "Name") .Throttle(TimeSpan.FromMilliseconds(500)) .Select(c => Name) .ObserveOnDispatcher() // Access to the ActivityRepository synchronized on the main thread... maybe not the best idea .Select(n => DomainContext.Activities.Where(a => a.Name == n).OrderByDescending(a => a.CreationTime).FirstOrDefault()) .Where(a => a != null); prototypeActivity .Select(a => a.Tags.Select(t => t.Name).ToArray()) .ObserveOnDispatcher() .Subscribe(t => Tags = t); prototypeActivity .Where(a => string.IsNullOrWhiteSpace(ExpectedEffort)) .Select(a => a.ExpectedEffort.ToString()) .ObserveOnDispatcher() .Subscribe(ee => ExpectedEffort = ee); CancelCommand = new RelayCommand(Cancel); }
public ServiceViewModel(ServiceBase service) { Name = service.ServiceName; //Get an observable for the current state var currentStateObs = this.ObservableForProperty(x => x.CurrentState).Value().StartWith(ServiceState.Stopped); //Map an observable to IsBusy that is True if the current state is *ing currentStateObs.Select ( s => s == ServiceState.Pausing || s == ServiceState.Starting || s == ServiceState.Stopping ) .Subscribe(busy => IsBusy = busy); StartCommand = new ReactiveCommand(currentStateObs.Select(s => s == ServiceState.Stopped)); StopCommand = new ReactiveCommand(currentStateObs.Select(s => s == ServiceState.Started || s == ServiceState.Paused)); PauseCommand = new ReactiveCommand(currentStateObs.Select(s => s == ServiceState.Started && service.CanPauseAndContinue)); ContinueCommand = new ReactiveCommand(currentStateObs.Select(s => s == ServiceState.Paused && service.CanPauseAndContinue)); AssignmentSubscription(StartCommand, () => ServiceBaseHelpers.StartService(service)); AssignmentSubscription(StopCommand, () => ServiceBaseHelpers.StopService(service)); AssignmentSubscription(PauseCommand, () => ServiceBaseHelpers.PauseService(service)); AssignmentSubscription(ContinueCommand, () => ServiceBaseHelpers.ContinueService(service)); // // Start on start time // StartCommand.Execute(null); }
public ReactivePropertyBasicsPageViewModel() { // mode is Flags. (default is all) // DistinctUntilChanged is no push value if next value is same as current // RaiseLatestValueOnSubscribe is push value when subscribed var allMode = ReactivePropertyMode.DistinctUntilChanged | ReactivePropertyMode.RaiseLatestValueOnSubscribe; // binding value from UI Control // if no set initialValue then initialValue is default(T). int:0, string:null... InputText = new ReactiveProperty<string>(initialValue: "", mode: allMode); // send value to UI Control DisplayText = InputText .Select(s => s.ToUpper()) // rx query1 .Delay(TimeSpan.FromSeconds(1)) // rx query2 .ToReactiveProperty(); // convert to ReactiveProperty ReplaceTextCommand = InputText .Select(s => !string.IsNullOrEmpty(s)) // condition sequence of CanExecute .ToReactiveCommand(); // convert to ReactiveCommand // ReactiveCommand's Subscribe is set ICommand's Execute // ReactiveProperty.Value set is push(& set) value ReplaceTextCommand.Subscribe(_ => InputText.Value = "Hello, ReactiveProperty!"); }
public FolderBrowserTabContentViewModel(IDialogService dialogService) { this.dialogService = dialogService; browseFolderCommand = ReactiveCommand.Create(); browseFolderCommand.Subscribe(_ => BrowseFolder()); }
public OrderViewModel() { this.DisplayName = "Add/Edit Order"; context = new LittleTravellerDataContext(); var CanSave = this.Changed.Select(_ => ValidateFields()).StartWith(false); SaveCommand = new ReactiveCommand(CanSave); SaveCommand.Subscribe(_ => SaveOrder()); NewOrderNumCommand = new ReactiveCommand(); NewOrderNumCommand.Subscribe(_ => NewOrderNum()); CloseTabCommand = new ReactiveCommand(); CloseTabCommand.Subscribe(_ => TabClosing()); SaveCommand.Subscribe(_ => SaveOrder()); var CanAddItem = this.Changed.Select(_ => CanAddItemValidate()).StartWith(false); AddItemCommand = new ReactiveCommand(CanAddItem); AddItemCommand.Subscribe(_ => AddItem()); DeleteItemCommand = new ReactiveCommand(); DeleteItemCommand.OfType<ItemOptionsClass>().Subscribe(item => DeleteItem(item)); CustomerOptions = (from cs in context.Customers select cs.CompanyName).ToList(); SeasonOptions = context.Seasons.ToList(); SizeTypeOptions = context.SizeTypes.ToList(); ItemOptions = new ReactiveCollection<ItemOptionsClass>(); _orderItems = new ObservableCollection<ItemOptionsClass>(); AllSeasonsChecked = true; AllSizeTypesChecked = true; FillItemOptions(); }
public void AllowConcurrentExecutionTest() { (new TestScheduler()).With(sched => { var fixture = new ReactiveCommand(null, true, sched); Assert.True(fixture.CanExecute(null)); var result = fixture.RegisterAsync(_ => Observable.Return(4).Delay(TimeSpan.FromSeconds(5), sched)) .CreateCollection(); Assert.Equal(0, result.Count); sched.AdvanceToMs(25); Assert.Equal(0, result.Count); fixture.Execute(null); Assert.True(fixture.CanExecute(null)); Assert.Equal(0, result.Count); sched.AdvanceToMs(2500); Assert.True(fixture.CanExecute(null)); Assert.Equal(0, result.Count); sched.AdvanceToMs(5500); Assert.True(fixture.CanExecute(null)); Assert.Equal(1, result.Count); }); }
public CategoryListViewModel(IThemeService themeService, IRssReader rssReader, IAsyncDownloadManager downloadManager, INavigationService navigationService, ILockscreenHelper lockscreen, IDownloadHelper downloadHelper) { _themeService = themeService; _rssReader = rssReader; _downloadManager = downloadManager; _navigationService = navigationService; _lockscreen = lockscreen; _downloadHelper = downloadHelper; AddMorePicturesCommand = Items.CountChanged .Select(_ => Items.Count < imageMetaData.Count()) .ToCommand(); AddMorePicturesCommand .RegisterAsyncTask(value => GetImages((int)value)); FullScreenCommand = new ReactiveCommand(); SetLockScreenCommand = new ReactiveCommand(); SetLockScreenCommand .RegisterAsyncTask(value => SetLockscreen(value as CategoryItem)); DownloadImageCommand = new ReactiveCommand(); DownloadImageCommand .RegisterAsyncTask(value => DownloadImage(value as CategoryItem)); }
public PostListViewModel() { service = new PostService(); var filters = MessageBus.Current.Listen<PostFilter>(MessageTypes.CurrentPostFilter) .Throttle(TimeSpan.FromSeconds(0.7), RxApp.DeferredScheduler); var refreshRequests = new ReactiveCommand(); GlobalCommands.RefreshCommand.RegisterCommand(refreshRequests); var filtersToRefresh = refreshRequests .Select((_, i) => i) .CombineLatest(filters, (i, f) => new {CommandId = i, Filter = f}) .DistinctUntilChanged(x => x.CommandId) .Select(x => x.Filter); var results = filters.Merge(filtersToRefresh) .ObserveOn(RxApp.TaskpoolScheduler) .Select(x => new { TargetFilter = x, Value = service.GetPosts(x) }); var latestResults = filters .CombineLatest(results, (f, r) => new { LatestFilter = f, LatestResult = r }) .Where(x => Equals(x.LatestFilter, x.LatestResult.TargetFilter)) .Select(x => x.LatestResult); latestResults .Select(x => x.Value.Select(p => new PostViewModel { Title = p.Title, FeedName = p.FeedName, FeedImage = new Uri(p.FeedImage), PublicationDate = p.PublicationDate }).ToList()) .ToProperty(this, x => x.Posts); }