public IReactiveBinding <TView, TViewModel, TProp> BindCommand <TView, TViewModel, TProp, TControl, TParam>( TViewModel viewModel, TView view, Expression <Func <TViewModel, TProp> > propertyName, Expression <Func <TView, TControl> > controlName, Func <TParam> withParameter, string toEvent = null) where TViewModel : class where TView : class, IViewFor <TViewModel> where TProp : ICommand { var ctlName = Reflection.SimpleExpressionToPropertyName(controlName); var viewPropGetter = Reflection.GetValueFetcherForProperty(typeof(TView), ctlName); IObservable <TProp> changed; IDisposable bindingDisposable = bindCommandInternal(viewModel, view, propertyName, viewPropGetter, Observable.Empty <object>(), toEvent, out changed, cmd => { var rc = cmd as IReactiveCommand; if (rc == null) { return(Legacy.ReactiveCommand.Create(x => cmd.CanExecute(x), _ => cmd.Execute(withParameter()))); } var ret = new ReactiveCommand(rc.CanExecuteObservable); ret.Subscribe(_ => rc.Execute(withParameter())); return(ret); }); return(new ReactiveBinding <TView, TViewModel, TProp>(view, viewModel, new string[] { ctlName }, new string[] { Reflection.SimpleExpressionToPropertyName(propertyName) }, changed, BindingDirection.OneWay, bindingDisposable)); }
/// <summary> /// This creates a ReactiveCommand that calls several child /// ReactiveCommands when invoked. Its CanExecute will match the /// combined result of the child CanExecutes (i.e. if any child /// commands cannot execute, neither can the parent) /// </summary> /// <param name="canExecute">An Observable that determines whether the /// parent command can execute</param> /// <param name="commands">The commands to combine.</param> public static ReactiveCommand CreateCombined(IObservable <bool> canExecute, params ReactiveCommand[] commands) { var childrenCanExecute = commands .Select(x => x.CanExecuteObservable) .CombineLatest(latestCanExecute => latestCanExecute.All(x => x != false)); var canExecuteSum = Observable.CombineLatest( canExecute.StartWith(true), childrenCanExecute, (parent, child) => parent && child); var ret = new ReactiveCommand(canExecuteSum); ret.Subscribe(x => commands.ForEach(cmd => cmd.Execute(x))); return(ret); }
/// <inheritdoc/> public override IDisposable Subscribe(IObserver <IList <TResult> > observer) => _innerCommand.Subscribe(observer);