private static async void ParallelExecutionTest() { var o = Observable.CombineLatest( Observable.Start(() => { Console.WriteLine("Executing 1st on Thread: {0}", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); return("Result A"); }), Observable.Start(() => { Console.WriteLine("Executing 2nd on Thread: {0}", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); return("Result B"); }), Observable.Start(() => { Console.WriteLine("Executing 3rd on Thread: {0}", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); return("Result C"); }) ).Finally(() => Console.WriteLine("Done!")); foreach (string r in await o.FirstAsync()) { Console.WriteLine(r); } }
public FormsRxPageViewModel() { _ = Observable.CombineLatest( Observable.FromEventPattern <PropertyChangedEventArgs>(this, nameof(PropertyChanged)) .Where(x => x.EventArgs.PropertyName == nameof(Name)), Observable.FromEventPattern <PropertyChangedEventArgs>(this, nameof(PropertyChanged)) .Where(x => x.EventArgs.PropertyName == nameof(Email)), Observable.FromEventPattern <PropertyChangedEventArgs>(this, nameof(PropertyChanged)) .Where(x => x.EventArgs.PropertyName == nameof(Phone)), (Name, Email, Phone) => validate() ) .Subscribe(); }
private IObservable <ProjectSummaryReport> summaryReportFromResponse(IProjectsSummary response, long workspaceId) { IObservable <ChartSegment[]> summarySegments = getChartSegmentsForWorkspace(response, workspaceId); IObservable <long[]> projectIdsNotSynced = getProjectIdsNotSynced(response); var result = Observable.CombineLatest( summarySegments, projectIdsNotSynced, (segments, ids) => new ProjectSummaryReport(segments, ids.Length) ); return(result); }
private void Sample5() { var x = Anime.Play(-5f, 5f, Easing.InOutSine(3f)); var y = Anime.Play(0f, 3f, Easing.InOutSine(1.5f)) .Play(0f, Easing.InOutSine(1.5f)); var z = Anime.Stay(0f); Observable.CombineLatest(x, y, z) .StopRecording() .SubscribeToPosition(cube); }
public static IObservable <TResult> Changed <TObj, TProperty1, TProperty2, TProperty3, TResult>( this TObj viewModel, Expression <Func <TObj, TProperty1> > propertyExpr1, Expression <Func <TObj, TProperty2> > propertyExpr2, Expression <Func <TObj, TProperty3> > propertyExpr3, Func <TProperty1, TProperty2, TProperty3, TResult> combine) { return(Observable.CombineLatest( viewModel.Changed(propertyExpr1), viewModel.Changed(propertyExpr2), viewModel.Changed(propertyExpr3), combine)); }
public ItemService(IAccountService accountService) { _accountService = accountService; _firestore = CrossCloudFirestore.Current.Instance; Item = _item.ToReadOnlyReactivePropertySlim(); Owner = _owner.ToReadOnlyReactivePropertySlim(); IsLiked = _isLiked.ToReadOnlyReactivePropertySlim(); IsOwner = Observable.CombineLatest(Item, _accountService.UserId, (item, userId) => item != null && item.OwnerId == userId) .ToReadOnlyReactivePropertySlim(); IsLoaded = _isLoaded.ToReadOnlyReactivePropertySlim(); IsDeleting = _deletingNotifier.ToReadOnlyReactivePropertySlim(); }
private IObservable <bool> CreateCanExecuteDealCommand() { return (Observable.CombineLatest( this.WhenAnyValue(x => x.InStoreGasStationOilDepot).Select(store => store != null), this.WhenAnyValue(x => x.Quantity).Select(quantity => quantity > 0), this.WhenAnyValue(x => x.SelectedEmployeeOtk).Select(user => user != null), this.WhenAnyValue(x => x.DateOfBook).Select(date => date != null), this.WhenAnyValue(x => x.NumberOfBook).Select(numberOfBook => !string.IsNullOrWhiteSpace(numberOfBook)), this.WhenAnyValue(x => x.SelectedEmployeeStore).Select(user => user != null), this.WhenAnyValue(x => x.CertificateQuality).Select(x => x != null), (a, b, c, d, e, f, g) => a && b && c && d && e && f && g)); }
private Outputs() { Output.all = new List <Output>(); departAdmin = new Output("STATIC_ADMIN_EXPEND", Root.def.economy.expend_depart_admin, Observable.CombineLatest(Depart.all.Select(x => x.adminExpendBase.obs), (IList <double> expend) => expend.Sum()).ToOBSValue()); reportChaoting = new Output("STATIC_REPORT_CHAOTING_TAX", Root.def.economy.report_chaoting_percent, Chaoting.inst.expectMonthTaxValue); reportChaoting.expend = () => Chaoting.inst.ReportMonthTax(reportChaoting.currValue.Value); }
public ExceptionViewModel() { Observable.CombineLatest( this.WhenPropertyChanged(x => x.Header), this.WhenPropertyChanged(x => x.Exception), Tuple.Create ) .Subscribe(UpdateMessages) .DisposeWith(this); this.ShowEmailSupport = DefaultShowEmailSupport; this.SupportEmailUri = DefaultSupportEmailUri; }
public VortexInstallerVM(InstallerVM installerVM) { Parent = installerVM; _TargetGame = installerVM.WhenAny(x => x.ModList.SourceModList.GameType) .ToProperty(this, nameof(TargetGame)); CanInstall = Observable.CombineLatest( this.WhenAny(x => x.TargetGame) .Select(game => VortexCompiler.IsActiveVortexGame(game)), installerVM.WhenAny(x => x.ModListLocation.InError), resultSelector: (isVortexGame, modListErr) => isVortexGame && !modListErr); }
// Example3 Combine a serious elements. public void CombineLatest() { var o = Observable.CombineLatest( Observable.Start(() => { Console.WriteLine("Executing 1st on Thread: {0}", Thread.CurrentThread.ManagedThreadId); return("Result A"); }), Observable.Start(() => { Console.WriteLine("Executing 2nd on Thread: {0}", Thread.CurrentThread.ManagedThreadId); return("Result B"); }), Observable.Start(() => { Console.WriteLine("Executing 3rd on Thread: {0}", Thread.CurrentThread.ManagedThreadId); return("Result C"); }) ).Finally(() => Console.WriteLine("Done!")); foreach (string r in o.First()) { Console.WriteLine(r); } }
private IObservable <PaginatedResponse <T> > CreatePagedObservable <T>(Task <HttpResponseMessage> httpResponseMessage) { return(Observable.CombineLatest <T, HttpResponseHeaders, PaginatedResponse <T> >( httpResponseMessage.Result.Content.ReadAsAsync <T>().ToObservable(), Observable.Return(httpResponseMessage.Result.Headers), (x, y) => { return new PaginatedResponse <T> { Response = x, ContinuationToken = y.GetValues("x-ms-continuationtoken").First() }; } )); }
public static IObservable <double> GetAverageOfLatest(this IEnumerable <IObservable <double> > sources) { int count = 1; var sums = sources.Aggregate( (left, right) => { //count how many satellites you have. count++; return(Observable.CombineLatest(left, right, (l, r) => l + r)); }); return(sums.Select(sum => sum / count)); }
public MainPageViewModel() { UpdateTextCommand = Observable.CombineLatest( Text, SelectedItem, (text, selectedItem) => !string.IsNullOrEmpty(text) && selectedItem != null) .ToReactiveCommand() .WithSubscribe(() => SelectedItem.Value.Text.Value = Text.Value); AddListItemCommand = Text.Select(x => !string.IsNullOrEmpty(x)) .ToReactiveCommand() .WithSubscribe(() => Items.Add(new ListItem(Text.Value))); }
public RoutedViewHost() { HorizontalContentAlignment = HorizontalAlignment.Stretch; VerticalContentAlignment = VerticalAlignment.Stretch; if (RxApp.InUnitTestRunner()) { ViewContractObservable = Observable.Never <string>(); return; } var platform = RxApp.DependencyResolver.GetService <IPlatformOperations>(); if (platform == null) { throw new Exception("Couldn't find an IPlatformOperations. This should never happen, your dependency resolver is broken"); } ViewContractObservable = Observable.FromEventPattern <SizeChangedEventHandler, SizeChangedEventArgs>(x => SizeChanged += x, x => SizeChanged -= x) .Select(_ => platform.GetOrientation()) .DistinctUntilChanged() .StartWith(platform.GetOrientation()) .Select(x => x != null ? x.ToString() : default(string)); var vmAndContract = Observable.CombineLatest( this.WhenAnyObservable(x => x.Router.CurrentViewModel), this.WhenAnyObservable(x => x.ViewContractObservable), (vm, contract) => Tuple.Create(vm, contract)); // NB: The DistinctUntilChanged is useful because most views in // WinRT will end up getting here twice - once for configuring // the RoutedViewHost's ViewModel, and once on load via SizeChanged vmAndContract.DistinctUntilChanged().Subscribe(x => { if (x.Item1 == null) { Content = DefaultContent; return; } var viewLocator = ViewLocator ?? ReactiveUI.ViewLocator.Current; var view = viewLocator.ResolveView(x.Item1, x.Item2) ?? viewLocator.ResolveView(x.Item1, null); if (view == null) { throw new Exception(String.Format("Couldn't find view for '{0}'.", x.Item1)); } view.ViewModel = x.Item1; Content = view; }, ex => RxApp.DefaultExceptionHandler.OnNext(ex)); }
public async Task UpdatesTreeDiff() { using var signal = new SemaphoreSlim(0, 1); var shaGenerator = new PseudoShaGenerator(); var addedFile = new TreeEntryChangesMock(ChangeKind.Added, true, Mode.NonExecutableFile, new ObjectId(shaGenerator.Generate()), "some/p.ath", false, Mode.Nonexistent, null, null); var firstCommit = CommitMock.GenerateCommit(shaGenerator, null, 0); var secondCommit = CommitMock.GenerateCommit(shaGenerator, firstCommit.Yield(), 1); var compareOptions = new CompareOptions(); var diff = new DiffMock(null, (oldTree, newTree, CompareOptions) => (oldTree, newTree, CompareOptions) == (firstCommit.Tree, secondCommit.Tree, compareOptions) ? new TreeChangesMock(((TreeEntryChanges)addedFile).Yield().ToList()) : throw new Exception("Compare was called with wrong arguments.")); var oldCommit = Observable.Return(new Variant <Commit, DiffTargets>(firstCommit)); var newCommit = Observable.Return(new Variant <Commit, DiffTargets>(secondCommit)); var head = new BranchMock(true, false, null, secondCommit, "HEAD"); var compareOptionsObs = Observable.Return(compareOptions); var repo = new RepositoryMock(new CommitMock[] { firstCommit, secondCommit }, new BranchCollectionMock(head.Yield().ToList()), null, diff); var repoObservable = Observable.Return(repo).Concat(Observable.Never <IRepositoryWrapper>()); var input = Observable .CombineLatest(oldCommit, newCommit, compareOptionsObs, repoObservable, (o, n, c, r) => new DiffViewModelInput(r, o, n, c)); Variant <List <TreeEntryChanges>, Unexpected>?value = null; var vm = new DiffViewModel(new TestSchedulers(), input); using var _ = vm.TreeDiff .Subscribe(val => { value = val; if (val.Is <List <TreeEntryChanges> >()) { signal.Release(); } }); if (value is null) { value = vm.TreeDiff.Value; } if (value is null) { throw new Exception("TreeDiff was not set."); } if (!value.Is <List <TreeEntryChanges> >()) { await signal.WaitAsync(TimeSpan.FromSeconds(10)); } Assert.IsTrue(value.Is <List <TreeEntryChanges> >()); }
/// <summary> /// Initializes a new instance of the <see cref="ViewModelViewHost"/> class. /// </summary> public ViewModelViewHost() { // NB: InUnitTestRunner also returns true in Design Mode if (ModeDetector.InUnitTestRunner()) { ViewContractObservable = Observable <string> .Never; return; } ViewContractObservable = Observable <string> .Default; var vmAndContract = Observable.CombineLatest( this.WhenAnyValue(x => x.ViewModel), this.WhenAnyObservable(x => x.ViewContractObservable), (vm, contract) => new { ViewModel = vm, Contract = contract, }); this.WhenActivated(() => { return(new[] { vmAndContract.Subscribe(x => { _viewContract = x.Contract; if (x.ViewModel == null) { Content = DefaultContent; return; } var viewLocator = ViewLocator ?? ReactiveUI.ViewLocator.Current; var view = viewLocator.ResolveView(x.ViewModel, x.Contract) ?? viewLocator.ResolveView(x.ViewModel, null); if (view == null) { throw new Exception(string.Format("Couldn't find view for '{0}'.", x.ViewModel)); } var castView = view as View; if (castView == null) { throw new Exception(string.Format("View '{0}' is not a subclass of '{1}'.", view.GetType().FullName, typeof(View).FullName)); } view.ViewModel = x.ViewModel; Content = castView; }) }); }); }
/// <summary> /// <para>Set INotifyDataErrorInfo's asynchronous validation, return value is self.</para> /// </summary> /// <param name="validator">If success return IO<null>, failure return IO<IEnumerable>(Errors).</param> /// <returns>Self.</returns> public ReactiveProperty <T> SetValidateNotifyError(Func <IObservable <T>, IObservable <IEnumerable?> > validator) { ValidatorStore.Value.Add(validator); //--- cache validation functions var validators = ValidatorStore.Value .Select(x => x(IsIgnoreInitialValidationError ? ValidationTrigger : ValidationTrigger.StartWith(LatestValue))) .ToArray(); //--- use copy ValidateNotifyErrorSubscription.Disposable = Observable .CombineLatest(validators) .Select(xs => { if (xs.Count == 0) { return(null); } if (xs.All(x => x == null)) { return(null); } var strings = xs .Where(x => x != null) .OfType <string>(); var others = xs .Where(x => x is not string) .Where(x => x != null) .SelectMany(x => x !.Cast <object?>()); return(strings.Concat(others)); }) .Subscribe(x => { var prevHasErrors = HasErrors; CurrentErrors = x; var currentHasErrors = HasErrors; var handler = ErrorsChanged; if (handler != null) { RaiseEventScheduler.Schedule(() => handler(this, SingletonDataErrorsChangedEventArgs.Value)); } var propertyChangedHandler = PropertyChanged; if (prevHasErrors != currentHasErrors && propertyChangedHandler != null) { RaiseEventScheduler.Schedule(() => propertyChangedHandler(this, SingletonPropertyChangedEventArgs.HasErrors)); } ErrorsTrigger.Value.OnNext(x); }); return(this); }
public TimeEntriesViewModel( ITogglDataSource dataSource, IInteractorFactory interactorFactory, IAnalyticsService analyticsService, ISchedulerProvider schedulerProvider, IRxActionFactory rxActionFactory, ITimeService timeService) { Ensure.Argument.IsNotNull(dataSource, nameof(dataSource)); Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory)); Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService)); Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider)); Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory)); Ensure.Argument.IsNotNull(timeService, nameof(timeService)); this.interactorFactory = interactorFactory; this.analyticsService = analyticsService; this.schedulerProvider = schedulerProvider; DelayDeleteTimeEntries = rxActionFactory.FromAction <long[]>(delayDeleteTimeEntries); ToggleGroupExpansion = rxActionFactory.FromAction <GroupId>(toggleGroupExpansion); CancelDeleteTimeEntry = rxActionFactory.FromAction(cancelDeleteTimeEntry); groupsFlatteningStrategy = new TimeEntriesGroupsFlattening(timeService); var deletingOrPressingUndo = timeEntriesPendingDeletionSubject.SelectUnit(); var collapsingOrExpanding = ToggleGroupExpansion.Elements; var visibleTimeEntries = interactorFactory.ObserveAllTimeEntriesVisibleToTheUser().Execute() .Select(timeEntries => timeEntries.Where(isNotRunning)) .ReemitWhen(deletingOrPressingUndo) .Select(timeEntries => timeEntries.Where(isNotDeleted)) .Select(group) .ReemitWhen(collapsingOrExpanding); TimeEntries = Observable.CombineLatest( visibleTimeEntries, dataSource.Preferences.Current, groupsFlatteningStrategy.Flatten) .AsDriver(schedulerProvider); Empty = TimeEntries .Select(groups => groups.None()) .AsDriver(schedulerProvider); Count = TimeEntries .Select(log => log.Sum(day => day.Items.Count)) .AsDriver(schedulerProvider); TimeEntriesPendingDeletion = timeEntriesPendingDeletionSubject.AsObservable().AsDriver(schedulerProvider); }
public RepositoryCloneViewModel( IOperatingSystem os, IConnectionManager connectionManager, IRepositoryCloneService service, IGitService gitService, IUsageService usageService, IUsageTracker usageTracker, IRepositorySelectViewModel gitHubTab, IRepositorySelectViewModel enterpriseTab, IRepositoryUrlViewModel urlTab) { this.os = os; this.connectionManager = connectionManager; this.service = service; this.gitService = gitService; this.usageService = usageService; this.usageTracker = usageTracker; GitHubTab = gitHubTab; EnterpriseTab = enterpriseTab; UrlTab = urlTab; tabs = new IRepositoryCloneTabViewModel[] { GitHubTab, EnterpriseTab, UrlTab }; var repository = this.WhenAnyValue(x => x.SelectedTabIndex) .SelectMany(x => tabs[x].WhenAnyValue(tab => tab.Repository)); Path = service.DefaultClonePath; repository.Subscribe(x => UpdatePath(x)); pathWarning = Observable.CombineLatest( repository, this.WhenAnyValue(x => x.Path), ValidatePathWarning) .ToProperty(this, x => x.PathWarning); var canClone = Observable.CombineLatest( repository, this.WhenAnyValue(x => x.Path), (repo, path) => repo != null && !service.DestinationFileExists(path) && !service.DestinationDirectoryExists(path)); var canOpen = Observable.CombineLatest( repository, this.WhenAnyValue(x => x.Path), (repo, path) => repo != null && !service.DestinationFileExists(path) && service.DestinationDirectoryExists(path)); Browse = ReactiveCommand.Create().OnExecuteCompleted(_ => BrowseForDirectory()); Clone = ReactiveCommand.CreateAsyncObservable( canClone, _ => repository.Select(x => new CloneDialogResult(Path, x?.CloneUrl))); Open = ReactiveCommand.CreateAsyncObservable( canOpen, _ => repository.Select(x => new CloneDialogResult(Path, x?.CloneUrl))); }
public static IObservable <Tuple <TProp1, TProp2, TProp3, TProp4> > WhenPropertiesChanged <TViewModel, TProp1, TProp2, TProp3, TProp4>(this TViewModel viewModel, Expression <Func <TViewModel, TProp1> > property1, Expression <Func <TViewModel, TProp2> > property2, Expression <Func <TViewModel, TProp3> > property3, Expression <Func <TViewModel, TProp4> > property4) where TViewModel : IObservableObject { return(Observable.CombineLatest( viewModel.WhenPropertyChanged(property1), viewModel.WhenPropertyChanged(property2), viewModel.WhenPropertyChanged(property3), viewModel.WhenPropertyChanged(property4), Tuple.Create)); }
//private readonly Random _random = new Random((int)DateTime.Now.Ticks); #endregion #region ctor public PlaybackQueue( IAudioPlaybackEngineSync audioPlayer //, IObservable<IChangeSet<Track> tracksCacheChanges ) { this._audioPlayer = audioPlayer ?? throw new ArgumentNullException(nameof(audioPlayer)); this._isShuffleActivated_BehaviorSubject = new BehaviorSubject <bool>(false).DisposeWith(this._disposables); this._sourcedEntries = new SourceList <PlaybackQueueEntry>().DisposeWith(this._disposables); Observable.CombineLatest( this._audioPlayer.WhenCanLoadChanged, this._audioPlayer.WhenCanPlayChanged, (canLoad, canPlay) => canLoad && !canPlay) .Where(canLoadButNotPlay => canLoadButNotPlay == true) .Subscribe((s) => { PlaybackQueueEntry next = null; // = this._playlistEntries.Items.FirstOrDefault(); this._playlistEntries.Edit(list => { next = list.FirstOrDefault(); if (next == null) { // unsubscribe from playlist? return; } list.RemoveAt(0); }); if (next == null) { return; } switch (next.Track) { case Track nextTrack: this._audioPlayer.LoadAndPlay(nextTrack); break; } }) .DisposeWith(this._disposables); //this._upNextEntries = new SourceList<PlaybackQueueEntry>().DisposeWith(this._disposables); this._playlistEntries = new SourceList <PlaybackQueueEntry>().DisposeWith(this._disposables); //this._upNextEntries.Connect().Bind(out this._upNextEntriesROOC); this._playlistEntries.Connect().Bind(out this._playlistEntriesROOC); }
public static IObservable <TResult> CombineVeryLatest <TLeft, TRight, TResult>(this IObservable <TLeft> leftSource, IObservable <TRight> rightSource, Func <TLeft, TRight, TResult> selector) { // code from http://stackoverflow.com/questions/3211134/how-to-throttle-event-stream-using-rx/3224723#3224723 return(Observable.Defer(() => { int l = -1, r = -1; // the last yielded index from each sequence return Observable.CombineLatest( leftSource.Select(Tuple.Create <TLeft, int>), // create a tuple which marks each item in a sequence with its index rightSource.Select(Tuple.Create <TRight, int>), (x, y) => new { x, y }) .Where(t => t.x.Item2 != l && t.y.Item2 != r) // don't yield a pair if the left or right has already been yielded .Do(t => { l = t.x.Item2; r = t.y.Item2; }) // record the index of the last item yielded from each sequence .Select(t => selector(t.x.Item1, t.y.Item1)); })); }
public PlayerWithPageContainerViewModel(HohoemaApp hohoemaApp, HohoemaPlaylist playlist) { HohoemaPlaylist = playlist; IsFillFloatContent = HohoemaPlaylist .ObserveProperty(x => x.IsPlayerFloatingModeEnable) .Select(x => !x) .ToReadOnlyReactiveProperty(); IsFillFloatContent_DelayedRead = IsFillFloatContent .Delay(TimeSpan.FromMilliseconds(300)) .ToReadOnlyReactiveProperty(); IsVisibleFloatContent = HohoemaPlaylist.ObserveProperty(x => x.IsDisplayMainViewPlayer) .ToReactiveProperty(mode: ReactivePropertyMode.DistinctUntilChanged); IsContentDisplayFloating = Observable.CombineLatest( IsFillFloatContent.Select(x => !x), IsVisibleFloatContent ) .Select(x => x.All(y => y)) .ToReactiveProperty(); HohoemaPlaylist.OpenPlaylistItem += HohoemaPlaylist_OpenPlaylistItem; IsVisibleFloatContent .Where(x => !x) .Subscribe(x => { ClosePlayer(); }); if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 4)) { Observable.Merge( IsVisibleFloatContent.Where(x => !x), IsContentDisplayFloating.Where(x => x) ) .Subscribe(async x => { var view = ApplicationView.GetForCurrentView(); if (view.IsViewModeSupported(ApplicationViewMode.CompactOverlay)) { var result = await view.TryEnterViewModeAsync(ApplicationViewMode.Default); } }); } }
public HeaterBandController(IObservable <double> setTemp, IObservable <double> bandTemp, TimeSpan maxHeatingTimeWithoutControl, IObservable <double> currentTemperature, IObservable <bool> heaterMasterSwitch) { var safeTemperature = currentTemperature.Timeout(maxHeatingTimeWithoutControl); var temperatureAboveBand = Observable.CombineLatest(setTemp, bandTemp, safeTemperature, (set, band, current) => current > set + band); var temperatureBelowBand = Observable.CombineLatest(setTemp, bandTemp, safeTemperature, (set, band, current) => current < set - band); var turnHeaterOff = temperatureAboveBand.Where(above => above == true).Select(_ => false); var turnHeaterOn = temperatureBelowBand.Where(below => below == true).Select(_ => true); var heaterControllerSwitch = Observable.Merge(turnHeaterOn, turnHeaterOff).DistinctUntilChanged(); HeaterOn = Observable.CombineLatest(heaterMasterSwitch, heaterControllerSwitch, (heaterMasterState, heaterControllerState) => heaterMasterState && heaterControllerState).OnErrorResumeNext(Observable.Return(false)); // turn off heater on error }
public PatcherLogDecorator( IProfileNameVm profileNameProvider, IPatcherNameVm patcherNameVm) { _logger = Observable.CombineLatest( profileNameProvider.WhenAnyValue(x => x.Name), patcherNameVm.WhenAnyValue(x => x.Name), (profile, patcher) => Log.Logger .ForContext(FunnelNames.Patcher, patcher) .ForContext(FunnelNames.Profile, profile)) .ToGuiProperty(this, nameof(Logger), Log.Logger .ForContext(FunnelNames.Patcher, patcherNameVm.Name) .ForContext(FunnelNames.Profile, profileNameProvider.Name), deferSubscription: true); }
public HelloWorldReactiveVM() { AddProperty <string>("FullName") .SubscribeTo(Observable.CombineLatest(FirstName, LastName, FullNameDelegate)) .SubscribedBy( AddProperty <int>("NameLength"), x => x.Select(name => name.Length) ) .SubscribedByAsync( AddProperty <int>("NameLengthAsync").SubscribedBy(_ => PushUpdates(), out IDisposable subs), async x => await GetNameLengthAsync(x)); AddInternalProperty <string>("Internal1"); AddInternalProperty("Internal2", 0); }
public IObservable <Vector2> OnMouseScreenClick() { var streamDown = Observable.EveryUpdate() .Where(_ => Input.GetMouseButtonDown(0)) .Select(_ => (Vector2)Input.mousePosition); var streamClicked = Observable.EveryUpdate() .Where(_ => Input.GetMouseButton(0)) .Select(_ => (Vector2)Input.mousePosition); return(Observable.CombineLatest(streamDown, streamClicked) .Where(positions => Vector2.Distance(positions[0], _centerPosition) < _range) .Select(_ => ((Vector2)Input.mousePosition - _centerPosition).normalized)); }
public DetailPageViewModel(TodoUsecase todoUsecase, TodoItem item, bool isNew) { Title = new ReactiveProperty <string>(item.Title); Description = new ReactiveProperty <string>(item.Description); IsDone = new ReactiveProperty <bool>(item.IsDone); Priority = new ReactiveProperty <int>(item.Priority); HasDueDate = new ReactiveProperty <bool>(item.DueDate.HasValue); DueDate = new ReactiveProperty <DateTime>(item.DueDate.HasValue ? item.DueDate.Value.LocalDateTime : DateTime.Today); // いずれかの項目が変化したら TodoItem を作り直す UpdatedItem = Observable.CombineLatest( Title, Description, Priority, HasDueDate, DueDate, (title, description, priority, hasDueDate, dueDate) => new TodoItem(item.Id, title, IsDone.Value, description, priority, hasDueDate ? dueDate : (DateTimeOffset?)null, item.CreateDate)) .ToReadOnlyReactiveProperty(); UpdatedItem.Subscribe(async x => { await todoUsecase.Update(x); }); DueDate.Subscribe(x => { if (x == DateTime.Today) { return; } HasDueDate.Value = true; }); HasDueDate.Subscribe(x => { System.Diagnostics.Debug.WriteLine($"{x}"); }); DeleteDueDateCommand.Subscribe(_ => { HasDueDate.Value = false; }); IsVisibleDone = Observable.Return(!isNew && !item.IsDone).ToReadOnlyReactiveProperty(); DoneCommand.Subscribe(async _ => { await todoUsecase.Done(UpdatedItem.Value); IsDone.Value = true; ClosePageRequest?.Invoke(this, Unit.Default); }); }
private void Subscribe1() { Observable.CombineLatest( Observable.Interval(TimeSpan.FromSeconds(1)).Select(x => { Debug.Log(1111); return(x); }), Observable.Interval(TimeSpan.FromSeconds(2)) ) .First() .Subscribe(_ => Debug.Log(2111), _ => Debug.Log(2112)) .AddTo(this); }