public void WithSubscribe() { var testScheduler = new TestScheduler(); var recorder1 = testScheduler.CreateObserver <string>(); var recorder2 = testScheduler.CreateObserver <string>(); var recorder3 = testScheduler.CreateObserver <string>(); var disposable1 = new CompositeDisposable(); var disposable2 = new CompositeDisposable(); var cmd = new ReactiveCommand() .WithSubscribe(() => recorder1.OnNext("x"), disposable1.Add) .WithSubscribe(() => recorder2.OnNext("x"), disposable2.Add) .WithSubscribe(() => recorder3.OnNext("x")); cmd.Execute(); testScheduler.AdvanceBy(10); disposable1.Dispose(); cmd.Execute(); testScheduler.AdvanceBy(10); disposable2.Dispose(); cmd.Execute(); recorder1.Messages.Is( OnNext(0, "x")); recorder2.Messages.Is( OnNext(0, "x"), OnNext(10, "x")); recorder3.Messages.Is( OnNext(0, "x"), OnNext(10, "x"), OnNext(20, "x")); }
public void ReactiveCommandSubscribe() { var testScheduler = new TestScheduler(); var recorder1 = testScheduler.CreateObserver <int>(); var recorder2 = testScheduler.CreateObserver <int>(); var cmd = new ReactiveCommand(); int counter = 0; Action countUp = () => counter++; cmd.Subscribe(countUp); Action recordAction1 = () => recorder1.OnNext(counter); cmd.Subscribe(recordAction1); Action recordAction2 = () => recorder2.OnNext(counter); cmd.Subscribe(recordAction2); cmd.Execute(); testScheduler.AdvanceBy(10); cmd.Execute(); testScheduler.AdvanceBy(10); cmd.Execute(); testScheduler.AdvanceBy(10); recorder1.Messages.Is( OnNext(0, 1), OnNext(10, 2), OnNext(20, 3)); recorder2.Messages.Is( OnNext(0, 1), OnNext(10, 2), OnNext(20, 3)); }
private void Start() { var where = new Subject <bool>(); var rxComm = new ReactiveCommand <string>(where, false); rxComm.Subscribe( value => Debug.LogFormat("Next: {0}", value), ex => Debug.LogException(ex), () => Debug.LogFormat("Complete")); var execute = rxComm.CanExecute; var result = rxComm.Execute("hello rx command."); Debug.LogFormat("CanExecute: {0}, Execute: {1}", execute, result); where.OnNext(true); execute = rxComm.CanExecute; result = rxComm.Execute("hello rx command."); Debug.LogFormat("CanExecute: {0}, Execute: {1}", execute, result); where.OnNext(false); execute = rxComm.CanExecute; result = rxComm.Execute("hello rx command."); Debug.LogFormat("CanExecute: {0}, Execute: {1}", execute, result); }
public void ExecuteFacilitatesAnyNumberOfInFlightExecutions() { new TestScheduler().With( scheduler => { IObservable <Unit> execute = Observables.Unit.Delay(TimeSpan.FromMilliseconds(500), scheduler); ReactiveCommand <Unit, Unit> fixture = ReactiveCommand.CreateFromObservable(() => execute, outputScheduler: scheduler); fixture.ToObservableChangeSet(ImmediateScheduler.Instance).Bind(out ReadOnlyObservableCollection <Unit> executed).Subscribe(); IDisposable sub1 = fixture.Execute().Subscribe(); IDisposable sub2 = fixture.Execute().Subscribe(); scheduler.AdvanceByMs(100); IDisposable sub3 = fixture.Execute().Subscribe(); scheduler.AdvanceByMs(200); IDisposable sub4 = fixture.Execute().Subscribe(); scheduler.AdvanceByMs(100); Assert.True(fixture.IsExecuting.FirstAsync().Wait()); Assert.Empty(executed); scheduler.AdvanceByMs(101); Assert.Equal(2, executed.Count); Assert.True(fixture.IsExecuting.FirstAsync().Wait()); scheduler.AdvanceByMs(200); Assert.Equal(3, executed.Count); Assert.True(fixture.IsExecuting.FirstAsync().Wait()); scheduler.AdvanceByMs(100); Assert.Equal(4, executed.Count); Assert.False(fixture.IsExecuting.FirstAsync().Wait()); }); }
public void WithSubscribeDisposableOverrideGenericVersion() { var testScheduler = new TestScheduler(); var recorder1 = testScheduler.CreateObserver <string>(); var recorder2 = testScheduler.CreateObserver <string>(); var recorder3 = testScheduler.CreateObserver <string>(); var cmd = new ReactiveCommand <string>() .WithSubscribe(x => recorder1.OnNext(x), out var disposable1) .WithSubscribe(x => recorder2.OnNext(x), out var disposable2) .WithSubscribe(x => recorder3.OnNext(x)); cmd.Execute("a"); testScheduler.AdvanceBy(10); disposable1.Dispose(); cmd.Execute("b"); testScheduler.AdvanceBy(10); disposable2.Dispose(); cmd.Execute("c"); recorder1.Messages.Is( OnNext(0, "a")); recorder2.Messages.Is( OnNext(0, "a"), OnNext(10, "b")); recorder3.Messages.Is( OnNext(0, "a"), OnNext(10, "b"), OnNext(20, "c")); }
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 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)); }
// Start is called before the first frame update void Start() { var reactiveCommand = new ReactiveCommand <int>(); reactiveCommand.Where(x => x % 2 == 0).Subscribe(x => Debug.LogFormat("{0} 是 偶数", x)); reactiveCommand.Where(x => x % 2 != 0).Timestamp().Subscribe(x => Debug.LogFormat("{0} 是基数数 {1}", x.Value, x.Timestamp)); reactiveCommand.Execute(10); reactiveCommand.Execute(11); }
// Use this for initialization void Start() { Subject <bool> subject = new Subject <bool>(); ReactiveCommand <string> reactiveCommand = new ReactiveCommand <string>(subject); reactiveCommand.Execute("1"); reactiveCommand.Subscribe(s => print(s)); reactiveCommand.Execute("2"); }
public bool Remove <TData>() { var result = _data.Remove <TData>(); if (result) { _portValueChanged.Execute(Unit.Default); } return(result); }
void Start() { ReactiveCommand command = new ReactiveCommand(); command.Subscribe(_ => { Debug.Log("Command executed!"); }); command.Execute(); command.Execute(); }
void Start() { //这里判定的是 Int 值,是否满足要求。然后 DoSomething... // 同样因为可传泛型,所以也可是对 Object 进行处理,可用性极强 var command = new ReactiveCommand <int>(); //响应命令,可传泛型 command.Where(_ => _ % 2 == 0).Subscribe(_ => print(_ + ">>>>>>能整除")); //增加 时间标记后,形参发生变化,需要指明 value 与 timestamp command.Where(_ => _ % 2 != 0).Timestamp().Subscribe(_ => print(_.Value + ">>>>>>不能" + _.Timestamp)); command.Execute(8); command.Execute(9); }
public void CreateTaskFacilitatesTPLIntegrationWithParameter() { ReactiveCommand <int, int> fixture = ReactiveCommand.CreateFromTask <int, int>(param => Task.FromResult(param + 1), outputScheduler: ImmediateScheduler.Instance); fixture.ToObservableChangeSet(ImmediateScheduler.Instance).Bind(out ReadOnlyObservableCollection <int> results).Subscribe(); fixture.Execute(3).Subscribe(); fixture.Execute(41).Subscribe(); Assert.Equal(2, results.Count); Assert.Equal(4, results[0]); Assert.Equal(42, results[1]); }
// Start is called before the first frame update void Start() { var reactiveCommand = new ReactiveCommand(); reactiveCommand.Subscribe(_ => { Debug.Log("Execute"); }); reactiveCommand.Execute(); reactiveCommand.Execute(); reactiveCommand.Execute(); }
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 void CompletelyDefaultReactiveCommandShouldFire() { var sched = new TestScheduler(); var fixture = new ReactiveCommand(null, sched); Assert.IsTrue(fixture.CanExecute(null)); string result = null; fixture.Subscribe(x => result = x as string); fixture.Execute("Test"); sched.Start(); Assert.AreEqual("Test", result); fixture.Execute("Test2"); sched.Start(); Assert.AreEqual("Test2", result); }
private void InputClicked(object sender, EventArgs e, ReactiveCommand <int, Unit> command, int value, string title) { var inputDialog = new AlertDialog.Builder(this); EditText userInput = new EditText(this); userInput.Text = value.ToString(); userInput.InputType = Android.Text.InputTypes.NumberFlagDecimal | Android.Text.InputTypes.ClassNumber; userInput.SetPadding(25, 25, 25, 25); inputDialog.SetTitle(title); inputDialog.SetView(userInput); inputDialog.SetPositiveButton( "Ok", (see, ess) => { if (!String.IsNullOrEmpty(userInput.Text) && userInput.Text != "0") { int parsedInput = int.Parse(userInput.Text); command.Execute(parsedInput).Subscribe(); } this.HideKeyboard(userInput); }); inputDialog.Show(); this.ShowKeyboard(userInput); }
private void OnStartClickedProxy() { _startButton.interactable = false; _startButton.GetComponent <Pulse>().Stop(); OnStartClicked.Execute(); }
public PatcherProgressViewModel(string itemID, string installDirectory, IScreen?screen = null) { HostScreen = screen ?? Locator.Current.GetService <IScreen>(); Activator = new ViewModelActivator(); patch = ReactiveCommand.CreateFromObservable(DownloadGoogleDriveFile); this.itemID = itemID; this.installDirectory = installDirectory; this.WhenActivated(disposable => { patch .ThrownExceptions .Subscribe(ex => HostScreen.Router.Navigate.Execute(new PatcherResultViewModel(Result.Failure, ex.Message, HostScreen)).Subscribe()) .DisposeWith(disposable); patch .Where(v => v >= 100) .Subscribe(ex => HostScreen.Router.Navigate.Execute(new PatcherResultViewModel(Result.Success, "The requested patch was downloaded and applied.", HostScreen)).Subscribe()) .DisposeWith(disposable); patch .Execute() .Subscribe() .DisposeWith(disposable); }); }
void Start() { // 创建鼠标按下事件流,返回true var mouseClickDownStream = Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonDown(0)) .Select(_ => true); // 创建鼠标抬起事件流,返回false var mouseClickUpStream = Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonUp(0)) .Select(_ => false); // 合并事件流 var mergeStream = Observable.Merge(mouseClickDownStream, mouseClickUpStream); // 创建命令 var reactiveCommand = new ReactiveCommand(mergeStream, false); // 订阅命令 reactiveCommand.Subscribe(x => { Debug.Log(x); }); // 订阅Update,执行命令 Observable.EveryUpdate() .Subscribe(_ => { reactiveCommand.Execute(); }); }
void Start() { float Speed = 0; var mouseDownSteam = Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonDown(0)).Select(_ => true); var mouseUpSteam = Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonUp(0)).Select(_ => false); var isMouseUp = Observable.Merge(mouseUpSteam, mouseDownSteam); var reactiveCMD = new ReactiveCommand(isMouseUp, false); Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonUp(0)) .Subscribe(_ => { Speed = 0f; }); reactiveCMD.Subscribe(_ => { Speed += 0.1f; Debug.LogFormat("reactive command execute{0}", Speed); }); Observable.EveryUpdate() .Where(_ => Speed < 10f) .Subscribe(_ => { reactiveCMD.Execute(); }); }
public SessionViewModel(SessionModel model ,IPersonFactory<Person> personFactory) { _model = model.ThrowIfNull("model"); _personFactory = personFactory.ThrowIfNull("personFactory"); AddNewPersonCommand = new ReactiveCommand(); AddNewPersonCommand.Subscribe(dontcare => _model.Participants.Add(_personFactory.GetNewPerson(Participants.Count))); Participants = _model.Participants .CreateDerivedCollection(x => new ParticipantViewModel(x)); Participants.ChangeTrackingEnabled = true; var deleteCanExecute = Observable.Merge(Participants.ItemChanged .Select(_ => Participants.Any(p => p.IsSelected)), Participants.CollectionCountChanged .Select(_ => Participants.Any(p=> p.IsSelected))); DeleteSelectedCommand = new ReactiveCommand ( deleteCanExecute ); DeleteSelectedCommand.Subscribe( x => { RemoveSelected(); } ); AddNewPersonCommand.Execute(null); }
public void ObservableExecuteFuncShouldBeObservableAndAct() { var executed_params = new List <object>(); var fixture = new ReactiveCommand(); fixture.Subscribe(x => executed_params.Add(x)); var observed_params = new ReplaySubject <object>(); fixture.Subscribe(observed_params.OnNext, observed_params.OnError, observed_params.OnCompleted); var range = Enumerable.Range(0, 5); foreach (var v in range) { fixture.Execute(v); } Assert.AreEqual(range.Count(), executed_params.Count); foreach (var v in range.Zip(executed_params.OfType <int>(), (e, a) => new { e, a })) { Assert.AreEqual(v.e, v.a); } range.ToObservable() .Zip(observed_params, (expected, actual) => new { expected, actual }) .Subscribe(x => Assert.AreEqual(x.expected, x.actual)); }
public UserViewModel(User user, ReactiveCommand <UserViewModel> showAnotherCommand) { User = user; ShowAnotherCommand = new ReactiveCommand(); ShowAnotherCommand.Subscribe(_ => showAnotherCommand.Execute(this)); }
// Update is called once per frame void Update() { fpsCounter += Time.deltaTime; if (fpsCounter >= fpsTarget) { fpsCounter = 0; UpdateFrame(wcAnimation.GetAnimationSprites()[animationFrameIndex]); animationFrameIndex++; if (animationFrameIndex >= wcAnimation.Count) { if (mode == Mode.Loop) { animationFrameIndex = 0; } else if (mode == Mode.PlayOnce) { animationFinished.Execute(true); if (destroyOnAnimationFinish != null) { Destroy(destroyOnAnimationFinish); } if (this != null) { Destroy(this); } } } } }
public void MultipleSubscribersShouldntDecrementRefcountBelowZero() { (new TestScheduler()).With(sched => { var fixture = new ReactiveCommand(); var results = new List <int>(); bool[] subscribers = new[] { false, false, false, false, false }; var output = fixture.RegisterAsync(_ => Observable.Return(5).Delay(TimeSpan.FromMilliseconds(5000), sched)); output.Subscribe(x => results.Add(x)); Enumerable.Range(0, 5).Run(x => output.Subscribe(_ => subscribers[x] = true)); Assert.True(fixture.CanExecute(null)); fixture.Execute(null); sched.AdvanceToMs(2000); Assert.False(fixture.CanExecute(null)); sched.AdvanceToMs(6000); Assert.True(fixture.CanExecute(null)); Assert.True(results.Count == 1); Assert.True(results[0] == 5); Assert.True(subscribers.All(x => x)); }); }
public void DisallowConcurrentExecutionTest() { (new TestScheduler()).With(sched => { var fixture = new ReactiveCommand(null, false, 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.False(fixture.CanExecute(null)); Assert.Equal(0, result.Count); sched.AdvanceToMs(2500); Assert.False(fixture.CanExecute(null)); Assert.Equal(0, result.Count); sched.AdvanceToMs(5500); Assert.True(fixture.CanExecute(null)); Assert.Equal(1, result.Count); }); }
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); }); }
private void Start() { var isOpen = new BoolReactiveProperty(false); var command = new ReactiveCommand <string>(isOpen); _ = WaitCommandAsync(command); // isOpen = false なので何も起きない command.Execute("Not work!"); // ReactiveCommandを有効化 isOpen.Value = true; // isOpen = true なのでコマンド実行 command.Execute("Work!"); }
private void Initialize(string dataType, string componentType, string portName) { UpdateDataTypeCommand = new ReactiveCommand(); UpdatePortNameCommand = new ReactiveCommand(); UpdateCompoentTypeCommand = new ReactiveCommand(); DataTypes = UpdateDataTypeCommand .SelectMany(_ => Observable.Start(() => _recordDescriptionRepository.GetDataTypes(componentType, portName)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => DataTypes.ClearOnScheduler()) .SelectMany(_ => _) .ToReactiveCollection(); PortNames = UpdatePortNameCommand .SelectMany(_ => Observable.Start(() => _recordDescriptionRepository.GetPortNames(dataType, componentType)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => PortNames.ClearOnScheduler()) .SelectMany(_ => _) .ToReactiveCollection(); ComponentTypes = UpdateCompoentTypeCommand .SelectMany(_ => Observable.Start(() => _recordDescriptionRepository.GetComponentTypes(dataType, portName)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => ComponentTypes.ClearOnScheduler()) .SelectMany(_ => _) .ToReactiveCollection(); DataType = dataType; PortName = portName; ComponentType = componentType; UpdateDataTypeCommand.Execute(null); UpdatePortNameCommand.Execute(null); UpdateCompoentTypeCommand.Execute(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 void RAOShouldActuallyRunOnTheTaskpool() { var deferred = RxApp.MainThreadScheduler; var taskpool = RxApp.TaskpoolScheduler; try { var testDeferred = new CountingTestScheduler(Scheduler.Immediate); var testTaskpool = new CountingTestScheduler(Scheduler.NewThread); RxApp.MainThreadScheduler = testDeferred; RxApp.TaskpoolScheduler = testTaskpool; var fixture = new ReactiveCommand(); var result = fixture.RegisterAsync(x => Observable.Return((int)x * 5).Delay(TimeSpan.FromSeconds(1), RxApp.TaskpoolScheduler)); fixture.Execute(1); Assert.Equal(5, result.First()); Assert.True(testDeferred.ScheduledItems.Count >= 1); Assert.True(testTaskpool.ScheduledItems.Count >= 1); } finally { RxApp.MainThreadScheduler = deferred; RxApp.TaskpoolScheduler = taskpool; } }
public void RAFShouldActuallyRunOnTheTaskpool() { var deferred = RxApp.MainThreadScheduler; var taskpool = RxApp.TaskpoolScheduler; try { var testDeferred = new CountingTestScheduler(Scheduler.Immediate); var testTaskpool = new CountingTestScheduler(Scheduler.NewThread); RxApp.MainThreadScheduler = testDeferred; RxApp.TaskpoolScheduler = testTaskpool; var fixture = new ReactiveCommand(); var result = fixture.RegisterAsyncFunction(x => { Thread.Sleep(1000); return((int)x * 5); }); fixture.Execute(1); Assert.Equal(5, result.First()); Assert.True(testDeferred.ScheduledItems.Count >= 1); Assert.True(testTaskpool.ScheduledItems.Count >= 1); } finally { RxApp.MainThreadScheduler = deferred; RxApp.TaskpoolScheduler = taskpool; } }
public override void Setup() { base.Setup(); _confirmButton.OnClickAsObservable() .Subscribe(_ => OnResetConfirmClicked.Execute()) .AddTo(this); }
void Start() { var reactiveCommand = new ReactiveCommand <int>(); reactiveCommand.Where(x => x % 2 == 0).Subscribe(x => { Debug.LogFormat("{0} 是偶数", x); }); reactiveCommand.Where(x => x % 2 == 1).Timestamp().Subscribe(x => { Debug.LogFormat("{0} 是奇数 {1}", x.Value, x.Timestamp); }); reactiveCommand.Execute(2); reactiveCommand.Execute(3); }
public void CanExecuteShouldChangeOnInflightOp() { (new TestScheduler()).With(sched => { var canExecute = sched.CreateHotObservable( sched.OnNextAt(0, true), sched.OnNextAt(250, false), sched.OnNextAt(500, true), sched.OnNextAt(750, false), sched.OnNextAt(1000, true), sched.OnNextAt(1100, false) ); var fixture = new ReactiveCommand(canExecute); int calculatedResult = -1; bool latestCanExecute = false; fixture.RegisterAsync(x => Observable.Return((int)x*5).Delay(TimeSpan.FromMilliseconds(900), RxApp.MainThreadScheduler)) .Subscribe(x => calculatedResult = x); fixture.CanExecuteObservable.Subscribe(x => latestCanExecute = x); // CanExecute should be true, both input observable is true // and we don't have anything inflight sched.AdvanceToMs(10); Assert.True(fixture.CanExecute(1)); Assert.True(latestCanExecute); // Invoke a command 10ms in fixture.Execute(1); // At 300ms, input is false sched.AdvanceToMs(300); Assert.False(fixture.CanExecute(1)); Assert.False(latestCanExecute); // At 600ms, input is true, but the command is still running sched.AdvanceToMs(600); Assert.False(fixture.CanExecute(1)); Assert.False(latestCanExecute); // After we've completed, we should still be false, since from // 750ms-1000ms the input observable is false sched.AdvanceToMs(900); Assert.False(fixture.CanExecute(1)); Assert.False(latestCanExecute); Assert.Equal(-1, calculatedResult); sched.AdvanceToMs(1010); Assert.True(fixture.CanExecute(1)); Assert.True(latestCanExecute); Assert.Equal(calculatedResult, 5); sched.AdvanceToMs(1200); Assert.False(fixture.CanExecute(1)); Assert.False(latestCanExecute); }); }
public DispatchViewModel(IScreen screen, ISession session) { HostScreen = screen; GoBack = HostScreen.Router.NavigateBack; Techs = new ReactiveList<Employee>(); Tickets = new ReactiveList<Ticket>(); var getFreshTechs = new ReactiveCommand(); getFreshTechs.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ => { Techs.Clear(); session.FetchResults<Employee>() .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => Techs.Add(x)); }); var getFreshTickets = new ReactiveCommand(); getFreshTickets.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ => { Tickets.Clear(); session.FetchResults<Ticket>() .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => Tickets.Add(x)); }); Refresh = new ReactiveCommand(session.IsWorking.Select(x => !x)); Refresh.Subscribe(_ => { getFreshTechs.Execute(default(object)); getFreshTickets.Execute(default(object)); }); Assign = new ReactiveCommand(Observable.CombineLatest( this.WhenAny( x => x.SelectedEmployee, y => y.SelectedTicket, (x, y) => x.Value != null && y.Value != null), Refresh.CanExecuteObservable, (x, y) => x && y)); Assign.Subscribe(_ => { using (session.ScopedChanges()) { var eventTaker = session.Take<TicketEvent>(); eventTaker.Add(new TicketEvent { Employee = SelectedEmployee, Ticket = SelectedTicket, TicketStatus = TicketStatus.Assigned, Time = DateTime.Now }); } }); _error = session.ThrownExceptions .Select(x => x.Message) .ObserveOn(RxApp.MainThreadScheduler) .ToProperty(this, x => x.Error); Refresh.Execute(default(object)); }
public void Command_Test() { //Given string result = null; string expected = Any.Create<string>(); ICommand command = new ReactiveCommand<string>(t => result = t, _ => true); //When bool canExecute = command.CanExecute(null); command.Execute(expected); //Then Assert.That(expected, Is.EqualTo(result)); Assert.That(canExecute, Is.True); }
public void CommandCanExecute_Test() { //Given string result = null; string expected = Any.Create<string>(); ICommand command = new ReactiveCommand<string>(t => result = t, _ => false); //When bool canExecute = command.CanExecute(null); command.Execute(expected); //Then Assert.That(canExecute, Is.False); Assert.That(result, Is.Null); }
public SettingsWindowViewModel() { CloseCommand = new ReactiveCommand(); ExceptionCommand = new ReactiveCommand(); KeyCommand = new ReactiveCommand(); KeyCommand.Subscribe(x => { var tuple = x as Tuple<string, HotKey>; if (tuple.Item2 == null) return; App.HotKeyManager.Unregister(Settings.ScreenKey); App.HotKeyManager.Unregister(Settings.SelectionKey); var tmpScreenKey = Settings.ScreenKey; var tmpSelectionKey = Settings.SelectionKey; switch (tuple.Item1) { case "ScreenKey": tmpScreenKey = tuple.Item2; break; case "SelectionKey": tmpSelectionKey = tuple.Item2; break; } App.HotKeyManager.Register(tmpScreenKey); App.HotKeyManager.Register(tmpSelectionKey); // Only apply the change if there hasn't been an error registering them Settings.GetType().GetProperty(tuple.Item1).SetValue(Settings, tuple.Item2); }); KeyCommand.ThrownExceptions.Subscribe(ex => { // We have to re-register the hotkeys here so // that both are registered with the system App.HotKeyManager.Unregister(Settings.ScreenKey); App.HotKeyManager.Unregister(Settings.SelectionKey); App.HotKeyManager.Register(Settings.ScreenKey); App.HotKeyManager.Register(Settings.SelectionKey); ExceptionCommand.Execute(ex); }); App.Settings.Changed.Subscribe(_ => this.RaisePropertyChanged("Settings")); }
public void FullCommand_Test() { //Given const string message = "Reactive"; string result = null; bool completed = false; Exception exception = null; string expected = Any.Create<string>(); var command = new ReactiveCommand<string>(t => result = t, _ => true,ex => exception = ex,() => completed = true ); //When bool canExecute = command.CanExecute(null); command.Execute(expected); command.OnError(new Exception(message)); command.OnCompleted(); //Then Assert.True(canExecute); Assert.AreEqual(result, expected); Assert.That(exception.Message, Is.EqualTo(message)); Assert.True(completed); }
public void ObservableExecuteFuncShouldBeObservableAndAct() { var executed_params = new List<object>(); var fixture = new ReactiveCommand(); fixture.Subscribe(x => executed_params.Add(x)); var observed_params = new ReplaySubject<object>(); fixture.Subscribe(observed_params.OnNext, observed_params.OnError, observed_params.OnCompleted); var range = Enumerable.Range(0, 5); foreach (var v in range) fixture.Execute(v); Assert.AreEqual(range.Count(), executed_params.Count); foreach (var v in range.Zip(executed_params.OfType<int>(), (e, a) => new { e, a })) { Assert.AreEqual(v.e, v.a); } range.ToObservable() .Zip(observed_params, (expected, actual) => new { expected, actual }) .Subscribe(x => Assert.AreEqual(x.expected, x.actual)); }
public PreviewWindowViewModel(string file) { ImageSource = file; SaveDlgCommand = new ReactiveCommand(); CloseCommand = new ReactiveCommand(); UploadCommand = new ReactiveCommand(); UploadCommand.Subscribe(async _ => { CloseCommand.Execute(null); await App.Uploader.Upload(file); }); SaveFileCommand = new ReactiveCommand(); SaveFileCommand.Subscribe(async x => { var saveFile = x as string; if (String.IsNullOrEmpty(saveFile)) return; await Task.Run(() => { using (var image = new Bitmap(ImageSource)) { switch (App.Settings.ImageFormat) { case ImageFormats.Png: image.Save(saveFile, ImageFormat.Png); break; case ImageFormats.Jpg: var encoder = ImageCodecInfo.GetImageEncoders().FirstOrDefault(c => c.FormatID == ImageFormat.Jpeg.Guid); using (var encParams = new EncoderParameters(1)) { encParams.Param[0] = new EncoderParameter(Encoder.Quality, App.Settings.ImageQuality); if (encoder != null) image.Save(saveFile, encoder, encParams); } break; case ImageFormats.Bmp: image.Save(saveFile, ImageFormat.Bmp); break; } } }); }); }
public void RAOShouldActuallyRunOnTheTaskpool() { var deferred = RxApp.MainThreadScheduler; var taskpool = RxApp.TaskpoolScheduler; try { var testDeferred = new CountingTestScheduler(Scheduler.Immediate); var testTaskpool = new CountingTestScheduler(Scheduler.NewThread); RxApp.MainThreadScheduler = testDeferred; RxApp.TaskpoolScheduler = testTaskpool; var fixture = new ReactiveCommand(); var result = fixture.RegisterAsync(x => Observable.Return((int)x*5).Delay(TimeSpan.FromSeconds(1), RxApp.TaskpoolScheduler)); fixture.Execute(1); Assert.Equal(5, result.First()); Assert.True(testDeferred.ScheduledItems.Count >= 1); Assert.True(testTaskpool.ScheduledItems.Count >= 1); } finally { RxApp.MainThreadScheduler = deferred; RxApp.TaskpoolScheduler = taskpool; } }
public void RegisterAsyncFunctionSmokeTest() { (new TestScheduler()).With(sched => { var fixture = new ReactiveCommand(); IReactiveDerivedList<int> results; results = fixture.RegisterAsync(_ => Observable.Return(5).Delay(TimeSpan.FromSeconds(5), sched)).CreateCollection(); var inflightResults = fixture.IsExecuting.CreateCollection(); sched.AdvanceToMs(10); Assert.True(fixture.CanExecute(null)); fixture.Execute(null); sched.AdvanceToMs(1005); Assert.False(fixture.CanExecute(null)); sched.AdvanceToMs(5100); Assert.True(fixture.CanExecute(null)); new[] {false, true, false}.AssertAreEqual(inflightResults); new[] {5}.AssertAreEqual(results); }); }
public TaxonManagementVM( IConnectivityService Connectivity, ITaxonService Taxa, IDiversityServiceClient Service, INotificationService Notification ) { this.Connectivity = Connectivity; this.Service = Service; this.Taxa = Taxa; this.Notification = Notification; _IsOnlineAvailable = this.ObservableToProperty(Connectivity.WifiAvailable(), x => x.IsOnlineAvailable); var localLists = this.FirstActivation() .SelectMany(_ => Taxa.getTaxonSelections() .ToObservable(ThreadPoolScheduler.Instance) .Select(list => new TaxonListVM(list))) .Publish(); LocalLists = localLists .ObserveOnDispatcher() .CreateCollection(); var onlineLists = localLists .IgnoreElements() //only download lists once the local ones are loaded .Concat(Observable.Return(null as TaxonListVM)) .CombineLatest(this.OnActivation(), (_, _2) => _2) .CheckConnectivity(Connectivity, Notification) .SelectMany(_ => { return Service.GetTaxonLists() .DisplayProgress(Notification, DiversityResources.TaxonManagement_State_DownloadingLists) .TakeUntil(this.OnDeactivation()); }) .ObserveOnDispatcher() .SelectMany(lists => lists.Where(list => !LocalLists.Any(loc => loc.Model == list)) // Filter lists already present locally .Select(list => new TaxonListVM(list)) ) .Publish(); PersonalLists = onlineLists.Where(vm => !vm.Model.IsPublicList) .CreateCollection(); PublicLists = onlineLists.Where(vm => vm.Model.IsPublicList) .CreateCollection(); onlineLists.Connect(); localLists.Connect(); Select = new ReactiveCommand<TaxonListVM>(vm => !vm.IsSelected && !vm.IsDownloading); Select.Subscribe(taxonlist => { foreach (var list in LocalLists) { if (list.Model.TaxonomicGroup == taxonlist.Model.TaxonomicGroup) list.Model.IsSelected = false; } Taxa.selectTaxonList(taxonlist.Model); }); Download = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Download .CheckConnectivity(Connectivity, Notification) .Subscribe(taxonlist => { if (Taxa.getTaxonTableFreeCount() > 0) { CurrentPivot = Pivot.Local; taxonlist.IsDownloading = true; makeListLocal(taxonlist); DownloadTaxonList(taxonlist) .DisplayProgress(Notification, DiversityResources.TaxonManagement_State_DownloadingList) .ObserveOnDispatcher() .ShowServiceErrorNotifications(Notification) .Subscribe(_ => { //Download Succeeded taxonlist.IsDownloading = false; if (Select.CanExecute(taxonlist)) Select.Execute(taxonlist); }, _ => //Download Failed { taxonlist.IsDownloading = false; removeLocalList(taxonlist); }, () => { }); } }); Delete = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Delete .Subscribe(taxonlist => { removeLocalList(taxonlist); }); Refresh = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Refresh .Subscribe(taxonlist => { if (Delete.CanExecute(taxonlist)) //Deletes synchronously Delete.Execute(taxonlist); if (Download.CanExecute(taxonlist)) Download.Execute(taxonlist); }); //Download all only on Personal pivot var canDownloadAll = this.WhenAny(x => x.CurrentPivot, x => x.GetValue()) .Select(p => p == Pivot.Personal) .CombineLatest(Connectivity.WifiAvailable(), (p, wi) => p && wi); DownloadAll = new ReactiveCommand(canDownloadAll, initialCondition: false); DownloadAll .SelectMany(_ => PersonalLists.ToArray()) .Where(vm => Download.CanExecute(vm)) .Subscribe(Download.Execute); }
public void MultipleResultsFromObservableShouldntDecrementRefcountBelowZero() { (new TestScheduler()).With(sched => { bool latestExecuting = false; var fixture = new ReactiveCommand(null, false, sched); var results = fixture .RegisterAsync(_ => new[] {1, 2, 3}.ToObservable()) .CreateCollection(); fixture.IsExecuting.Subscribe(x => latestExecuting = x); fixture.Execute(1); sched.Start(); Assert.Equal(3, results.Count); Assert.Equal(false, latestExecuting); }); }
public void MultipleSubscribersShouldntDecrementRefcountBelowZero() { (new TestScheduler()).With(sched => { var fixture = new ReactiveCommand(); var results = new List<int>(); bool[] subscribers = new[] {false, false, false, false, false}; var output = fixture.RegisterAsync(_ => Observable.Return(5).Delay(TimeSpan.FromMilliseconds(5000), sched)); output.Subscribe(x => results.Add(x)); Enumerable.Range(0, 5).Run(x => output.Subscribe(_ => subscribers[x] = true)); Assert.True(fixture.CanExecute(null)); fixture.Execute(null); sched.AdvanceToMs(2000); Assert.False(fixture.CanExecute(null)); sched.AdvanceToMs(6000); Assert.True(fixture.CanExecute(null)); Assert.True(results.Count == 1); Assert.True(results[0] == 5); Assert.True(subscribers.All(x => x)); }); }
private void Initialize(string dataType, string componentType, string portName) { UpdateDataTypeCommand = new ReactiveCommand(); UpdatePortNameCommand = new ReactiveCommand(); UpdateCompoentTypeCommand = new ReactiveCommand(); DataTypes = UpdateDataTypeCommand .SelectMany(_=>Observable.Start(()=>_recordDescriptionRepository.GetDataTypes(componentType,portName)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => DataTypes.ClearOnScheduler()) .SelectMany(_=>_) .ToReactiveCollection(); PortNames = UpdatePortNameCommand .SelectMany(_=>Observable.Start(()=>_recordDescriptionRepository.GetPortNames(dataType,componentType)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => PortNames.ClearOnScheduler()) .SelectMany(_=>_) .ToReactiveCollection(); ComponentTypes = UpdateCompoentTypeCommand .SelectMany(_=>Observable.Start(()=>_recordDescriptionRepository.GetComponentTypes(dataType,portName)) .Catch((Exception ex) => Messenger.Raise(new InformationMessage("データベースアクセスに失敗しました。", "エラー", "ShowError")))) .Do(_ => ComponentTypes.ClearOnScheduler()) .SelectMany(_=>_) .ToReactiveCollection(); DataType = dataType; PortName = portName; ComponentType = componentType; UpdateDataTypeCommand.Execute(null); UpdatePortNameCommand.Execute(null); UpdateCompoentTypeCommand.Execute(null); }
public MainWindowViewModel() { ImageHistory = new ReactiveList<string>(); VisiblityCommand = new ReactiveCommand(); DropCommand = new ReactiveCommand(); SettingsCommand = new ReactiveCommand(); UploadCommand = new ReactiveCommand(); ScreenCommand = new ReactiveCommand(); SelectionCommand = new ReactiveCommand(this.WhenAnyValue(x => x.IsCaptureWindowOpen).Select(x => !x)); SelectionCommand.Subscribe(_ => IsCaptureWindowOpen = true); DropCommand.Subscribe(async ev => { var e = ev as DragEventArgs; if (e == null) return; if (!e.Data.GetDataPresent(DataFormats.FileDrop)) return; var data = e.Data.GetData(DataFormats.FileDrop) as IEnumerable<string>; if (data == null) return; foreach (var file in data) await App.Uploader.Upload(file); }); OpenCommand = new ReactiveCommand(); OpenCommand.Subscribe(async files => { foreach (var file in (IEnumerable<string>)files) await App.Uploader.Upload(file); }); MessageBus.Current.Listen<object>("CaptureWindow").Subscribe(_ => IsCaptureWindowOpen = false); Observable.FromEventPattern<KeyPressedEventArgs>(handler => App.HotKeyManager.KeyPressed += handler, handler => App.HotKeyManager.KeyPressed -= handler).Select(x => x.EventArgs).Subscribe(e => { var hk = e.HotKey; if (hk.Equals(App.Settings.ScreenKey)) ScreenCommand.Execute(null); else if (hk.Equals(App.Settings.SelectionKey)) { if (SelectionCommand.CanExecute(null)) SelectionCommand.Execute(null); } }); Observable.FromEventPattern<UploaderEventArgs>(handler => App.Uploader.ImageUploadSuccess += handler, handler => App.Uploader.ImageUploadSuccess -= handler).Select(x => x.EventArgs).Subscribe(e => { if (App.Settings.CopyLinks) Clipboard.SetDataObject(e.ImageUrl); ImageHistory.Add(e.ImageUrl); if (!App.Settings.Notifications) return; var msg = string.Format("Image Uploaded: {0}", e.ImageUrl); MessageBus.Current.SendMessage(new NotificationMessage(Title, msg, BalloonIcon.Info)); }); Observable.FromEventPattern<UploaderEventArgs>(handler => App.Uploader.ImageUploadFailed += handler, handler => App.Uploader.ImageUploadFailed -= handler).Select(x => x.EventArgs).Subscribe(e => { if (!App.Settings.Notifications) return; var msg = string.Format("Image Failed: {0}", e.Exception.Message); MessageBus.Current.SendMessage(new NotificationMessage(Title, msg, BalloonIcon.Error)); }); App.Settings.ObservableForProperty(x => x.AlwaysOnTop).Subscribe(_ => this.RaisePropertyChanged("IsTopmost")); }
public void RAFShouldActuallyRunOnTheTaskpool() { var deferred = RxApp.MainThreadScheduler; var taskpool = RxApp.TaskpoolScheduler; try { var testDeferred = new CountingTestScheduler(Scheduler.Immediate); var testTaskpool = new CountingTestScheduler(Scheduler.NewThread); RxApp.MainThreadScheduler = testDeferred; RxApp.TaskpoolScheduler = testTaskpool; var fixture = new ReactiveCommand(); var result = fixture.RegisterAsyncFunction(x => { Thread.Sleep(1000); return (int)x*5; }); fixture.Execute(1); Assert.Equal(5, result.First()); Assert.True(testDeferred.ScheduledItems.Count >= 1); Assert.True(testTaskpool.ScheduledItems.Count >= 1); } finally { RxApp.MainThreadScheduler = deferred; RxApp.TaskpoolScheduler = taskpool; } }