public static ReactiveCommand <TOut> SetNewCommand <T, TOut>(this ReactiveCommand <TOut> command, T target, Expression <Func <T, ReactiveCommand <TOut> > > memberLamda) where T : class { if (command == null) { throw new ArgumentNullException(nameof(command)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } if (memberLamda == null) { throw new ArgumentNullException(nameof(memberLamda)); } var memberSelectorExpression = memberLamda.Body as MemberExpression; if (memberSelectorExpression == null) { throw new Exception("Not a member expression? " + target); } var property = memberSelectorExpression.Member as PropertyInfo; if (property == null) { throw new Exception("Not a property? " + target); } command.DefaultSetup(target.GetCallerName(property)); property.SetValue(target, command, null); return(command); }
static ReactiveCommand CreateCommand(string name = null) { var command = new ReactiveCommand(); command.DefaultSetup(name); return(command); }
/// <summary> /// RegisterAsyncTask registers an TPL/Async method that runs when a /// Command gets executed and returns no result. /// </summary> /// <param name="calculationFunc">The function to be run in the /// background.</param> /// <returns>An Observable that signals when the Task completes, on /// the UI thread.</returns> public static IObservable <Unit> RegisterAsyncTask(this LegacyRxCmd This, Func <object, Task> calculationFunc) { Contract.Requires(calculationFunc != null); // NB: This PermaRef isn't exactly correct, but the people using // this method probably are Doing It Wrong, so let's let them // continue to do so. return(This.RegisterAsync(x => calculationFunc(x).ToObservable()) .Publish().PermaRef()); }
/// <summary> /// RegisterAsyncFunction registers an asynchronous method that returns a result /// to be called whenever the Command's Execute method is called. /// </summary> /// <param name="calculationFunc">The function to be run in the /// background.</param> /// <param name="scheduler"></param> /// <returns>An Observable that will fire on the UI thread once per /// invoecation of Execute, once the async method completes. Subscribe to /// this to retrieve the result of the calculationFunc.</returns> public static IObservable <TResult> RegisterAsyncFunction <TResult>(this LegacyRxCmd This, Func <object, TResult> calculationFunc, IScheduler scheduler = null) { Contract.Requires(calculationFunc != null); var asyncFunc = calculationFunc.ToAsync(scheduler ?? RxApp.TaskpoolScheduler); return(This.RegisterAsync(asyncFunc)); }
public override async void Start() { base.Start(); var canExecute = this.WhenAny(model => model.DistrictSetting.SelectedDistrict, change => change.Value != null); this.Continue = new ReactiveCommand(canExecute); this.Continue.Subscribe(o => this.ShowViewModel<PersonalFeedsViewModel>()); }
/// <summary> /// RegisterAsyncAction registers an asynchronous method that runs /// whenever the Command's Execute method is called and doesn't return a /// result. /// </summary> /// <param name="calculationFunc">The function to be run in the /// background.</param> public static IObservable <Unit> RegisterAsyncAction(this LegacyRxCmd This, Action <object> calculationFunc, IScheduler scheduler = null) { Contract.Requires(calculationFunc != null); // NB: This PermaRef isn't exactly correct, but the people using // this method probably are Doing It Wrong, so let's let them // continue to do so. return(This.RegisterAsyncFunction(x => { calculationFunc(x); return new Unit(); }, scheduler) .Publish().PermaRef()); }
public static ReactiveCommand CreateCommand(string name, bool allowMultiple, bool initialCondition = true) { if (name == null) { throw new ArgumentNullException(nameof(name)); } var command = new ReactiveCommand(null, allowMultiple, null, initialCondition); command.DefaultSetup(name); return(command); }
protected override void OnInitialize() { base.OnInitialize(); var sl = this.WhenAnyValue(x => x.ServerList.IsUpdating, x => x.SystemInfo.IsInternetAvailable, (updating, internetAvailable) => !updating && internetAvailable) .ObserveOn(RxApp.MainThreadScheduler); var processingObservable = this.WhenAnyValue(x => x.ServerList.DownloadingServerList, x => x.ServerList.IsUpdating) .ObserveOn(RxApp.MainThreadScheduler); ReactiveUI.ReactiveCommand.CreateAsyncTask(processingObservable.Select(x => !x.Item1 && !x.Item2), async x => await Reload()) .SetNewCommand(this, x => x.ReloadCommand) .Subscribe(); ReactiveUI.ReactiveCommand.CreateAsyncTask(processingObservable.Select(x => x.Item1 || x.Item2), async x => await AbortInternal()) .SetNewCommand(this, x => x.AbortCommand) .Subscribe(); this.SetCommand(x => x.SwitchQuickPlay).Subscribe(SwitchQuickPlayAction); this.SetCommand(x => x.QActionCommand).RegisterAsyncTask(QAction).Subscribe(); this.SetCommand(x => x.AddServerCommand).Subscribe(x => ShowAddServer()); this.SetCommand(x => x.AddServerOKCommand).RegisterAsyncTask(AddServerOK).Subscribe(); this.SetCommand(x => x.AddServerCancelCommand).Subscribe(x => CancelAddServer()); RefreshFilterCommand = ReactiveUI.ReactiveCommand.CreateAsyncTask(x => RefreshFilterWithDelay()); CreateLibrary(DomainEvilGlobal.SelectedGame.ActiveGame); _contentManager.InitialServerSync(true); CgsUpdate = ReactiveUI.ReactiveCommand.CreateAsyncTask(OnCgsUpdate).DefaultSetup("OnCgsUpdate"); CgsUpdate.Subscribe(); var onActivate = ReactiveUI.ReactiveCommand.CreateAsyncTask(x => OnActivateInternal()).DefaultSetup("OnActivate"); onActivate.Subscribe(); var isEnabledQuery = this.WhenAnyValue(x => x.IsActive); isEnabledQuery.Subscribe(x => _settings.AppOptions.ServerListEnabled = x); isEnabledQuery.Where(x => x) .Skip(1) .Subscribe(x => onActivate.Execute(null)); this.WhenAnyValue(x => x.ServerList.ServerQueryQueue.State) .Subscribe(x => ProgressState = x); this.WhenAnyValue(x => x.ServerList.DownloadingServerList) .Subscribe(SwitchProgressState); }
static ReactiveCommand CreateCommand(IObservable <bool> ena, string name, bool initialCondition = true) { if (ena == null) { throw new ArgumentNullException(nameof(ena)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } var command = new ReactiveCommand(ena, initialCondition); command.DefaultSetup(name); return(command); }
/// <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 LegacyRxCmd 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 LegacyRxCmd(canExecuteSum); ret.Subscribe(x => { foreach (var cmd in commands) { cmd.Execute(x); } }); return(ret); }
/// <summary> /// RegisterAsyncTask registers an TPL/Async method that runs when a /// Command gets executed and returns the result /// </summary> /// <returns>An Observable that will fire on the UI thread once per /// invoecation of Execute, once the async method completes. Subscribe to /// this to retrieve the result of the calculationFunc.</returns> public static IObservable <TResult> RegisterAsyncTask <TResult>(this LegacyRxCmd This, Func <object, Task <TResult> > calculationFunc) { Contract.Requires(calculationFunc != null); return(This.RegisterAsync(x => calculationFunc(x).ToObservable())); }
public CommentViewModel() { SaveCommand = new ReactiveUI.Legacy.ReactiveCommand(this.WhenAnyValue(x => x.Comment).Select(x => !string.IsNullOrEmpty(x))); }