public NeuronTreePaneViewModel(INeuronApplicationService neuronApplicationService = null, INeuronQueryService neuronQueryService = null, INotificationApplicationService notificationApplicationService = null, IStatusService statusService = null, IDialogService dialogService = null, IOriginService originService = null) { this.dialogService = dialogService ?? Locator.Current.GetService <IDialogService>(); this.neuronApplicationService = neuronApplicationService ?? Locator.Current.GetService <INeuronApplicationService>(); this.neuronQueryService = neuronQueryService ?? Locator.Current.GetService <INeuronQueryService>(); this.notificationApplicationService = notificationApplicationService ?? Locator.Current.GetService <INotificationApplicationService>(); this.statusService = statusService ?? Locator.Current.GetService <IStatusService>(); this.originService = originService ?? Locator.Current.GetService <IOriginService>(); this.statusService.WhenPropertyChanged(s => s.Message) .Subscribe(s => this.StatusMessage = s.Sender.Message); bool DefaultPredicate(Node <Neuron, int> node) => node.IsRoot; var cache = new SourceCache <Neuron, int>(x => x.UIId); this.AddCommand = ReactiveCommand.Create <object>(async(parameter) => await this.OnAddClicked(cache, parameter)); this.SetRegionCommand = ReactiveCommand.Create <object>(async(parameter) => await this.OnSetRegionIdClicked(parameter)); this.ReloadCommand = ReactiveCommand.Create(async() => await this.OnReloadClicked(cache)); this.cleanUp = cache.AsObservableCache().Connect() .TransformToTree(child => child.CentralUIId, Observable.Return((Func <Node <Neuron, int>, bool>)DefaultPredicate)) .Transform(e => e.Item.Type == RelativeType.Postsynaptic ? (NeuronViewModelBase)(new PostsynapticViewModel(this, e.Item.Tag, e, cache)) : (NeuronViewModelBase)(new PresynapticViewModel(this, e.Item.Tag, e, cache))) .Bind(out this.children) .DisposeMany() .Subscribe(); this.Target = null; this.Loading = false; this.IconSourcePath = @"pack://application:,,,/d23-wpf;component/images/hierarchy.ico"; }
public LineScroller(FileInfo file, IObservable<ILineProvider> latest, IObservable<ScrollRequest> scrollRequest, ILogger logger, IScheduler scheduler = null) { if (file == null) throw new ArgumentNullException(nameof(file)); if (latest == null) throw new ArgumentNullException(nameof(latest)); if (logger == null) throw new ArgumentNullException(nameof(logger)); logger.Info($"Constructing file tailer for {file.FullName}"); var lines = new SourceCache<Line, LineKey>(l=>l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); var aggregator = latest.CombineLatest(scrollRequest, (currentLines, scroll) => currentLines.ReadLines(scroll).ToArray()) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous,Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) innerCache.Remove(removed); if (added.Any()) innerCache.AddOrUpdate(added); }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
protected DataServiceBase( ISettingsService settingsService, INotificationCenterService notificationCenter) { _readOnlyCache = cache.AsObservableCache(); this.cache.DisposeWith(disposables); this.settingsService = settingsService; this.notificationCenter = notificationCenter; }
public StrategyService() { _availableEntitiesCache = new SourceCache <IStrategy, String>(price => price.EntityCacheKey); _availableEntities = _availableEntitiesCache.AsObservableCache(); _availableEntitiesCache.Edit(innerCache => { innerCache.AddOrUpdate(Enumerable.Range(0, 5).Select(_ => new Strategy())); }); }
public LineScroller([NotNull] IObservable <ILineProvider> latest, [NotNull] IObservable <ScrollRequest> scrollRequest) { if (latest == null) { throw new ArgumentNullException(nameof(latest)); } if (scrollRequest == null) { throw new ArgumentNullException(nameof(scrollRequest)); } var lines = new SourceCache <Line, LineKey>(l => l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); latest = latest.Synchronize(locker); var aggregator = latest .CombineLatest(scrollRequest, (currentLines, scroll) => new { currentLines, scroll }) .Sample(TimeSpan.FromMilliseconds(50)) .Select(x => { if (x.scroll.PageSize == 0 || x.currentLines.Count == 0) { return(new Line[0]); } return(x.currentLines.ReadLines(x.scroll).ToArray()); }) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous, Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) { innerCache.Remove(removed); } if (added.Any()) { innerCache.AddOrUpdate(added); } }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
public LineScroller([NotNull] IObservable <ILineProvider> latest, [NotNull] IObservable <ScrollRequest> scrollRequest) { if (latest == null) { throw new ArgumentNullException(nameof(latest)); } if (scrollRequest == null) { throw new ArgumentNullException(nameof(scrollRequest)); } var lines = new SourceCache <Line, LineKey>(l => l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); latest = latest.Synchronize(locker); var aggregator = latest .CombineLatest(scrollRequest, (currentLines, scroll) => { try { return(currentLines.ReadLines(scroll).ToArray()); } catch (Exception ex) { throw ex; } }) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous, Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) { innerCache.Remove(removed); } if (added.Any()) { innerCache.AddOrUpdate(added); } }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
public LineScroller(FileInfo file, IObservable <ILineProvider> latest, IObservable <ScrollRequest> scrollRequest, ILogger logger, IScheduler scheduler = null) { if (file == null) { throw new ArgumentNullException(nameof(file)); } if (latest == null) { throw new ArgumentNullException(nameof(latest)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } logger.Info($"Constructing file tailer for {file.FullName}"); var lines = new SourceCache <Line, LineKey>(l => l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); var aggregator = latest.CombineLatest(scrollRequest, (currentLines, scroll) => currentLines.ReadLines(scroll).ToArray()) .RetryWithBackOff <Line[], Exception>((ex, i) => TimeSpan.FromSeconds(1)) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous, Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) { innerCache.Remove(removed); } if (added.Any()) { innerCache.AddOrUpdate(added); } }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
public void ImageExplorerViewModel_SyncsIntialItemsFromCache_WhenItemsAvailable() => new TestScheduler().With(scheduler => { var source = new SourceCache <ImageHandle, string>(x => x.LoadingSettings.FilePath); source.AddOrUpdate(GetDummyHandle("foo")); var sut = new ImageExplorerViewModel(source.AsObservableCache()); sut.Activator.Activate(); scheduler.AdvanceBy(2); Assert.Equal(1, sut.Children.Count); });
public VendingMachine(IVendingMachineManager manager, Currency currency, uint maxCapacityPerProduct) { ProfitHelper = this.WhenAnyValue(x => x.Income, x => x.Expenses, (income, expenses) => income - expenses).ToProperty(source: this, property: x => x.Profit); StockStatus.SubscribeMany((_) => UpdateProfitExcludingCurrentStockOutlaySubscriptionFactory()); this.ObservableForProperty(x => x.Profit).Subscribe(x => UpdateProfitExcludingCurrentStockOutlay()); Currency = currency; MaxCapacityPerProduct = maxCapacityPerProduct; this.manager = manager; //No need to worry about null because of C# 8.0. // (It would be caught at compile-time) //To have IVendingMachineOperator be nullable, //I'd have to declare it as IVendingMachineOperator? this.manager.SetupVendingMachine(_stock.AsObservableCache()).Subscribe(StockProduct); }
public PriceService() { _availableEntitiesCache = new SourceCache <IPrice, String>(price => price.EntityCacheKey); _availableEntities = _availableEntitiesCache.AsObservableCache(); TestHelper.Assets.ForEach(asset => _availableEntitiesCache.AddOrUpdate(new Price(DateTime.Now.Ticks, asset, asset.StartingPrice))); Observable .Interval(TimeSpan.FromMilliseconds(500)) .Subscribe((_) => { var price = CreatePrice(); _availableEntitiesCache.AddOrUpdate(price); }); }
public LineScroller([NotNull] IObservable<ILineProvider> latest, [NotNull] IObservable<ScrollRequest> scrollRequest) { if (latest == null) throw new ArgumentNullException(nameof(latest)); if (scrollRequest == null) throw new ArgumentNullException(nameof(scrollRequest)); var lines = new SourceCache<Line, LineKey>(l => l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); latest = latest.Synchronize(locker); var aggregator = latest .CombineLatest(scrollRequest, (currentLines, scroll) => { try { var x = currentLines.ReadLines(scroll).ToArray(); return x; } catch (Exception ex) { throw ex; } }) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous, Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) innerCache.Remove(removed); if (added.Any()) innerCache.AddOrUpdate(added); }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
public void ImageExplorerViewModel_SelectionsObservableFires_WhenNewItemSelected() => new TestScheduler().With(scheduler => { bool success = false; var source = new SourceCache <ImageHandle, string>(x => x.LoadingSettings.FilePath); source.AddOrUpdate(GetDummyHandle("foo")); source.AddOrUpdate(GetDummyHandle("bar")); var sut = new ImageExplorerViewModel(source.AsObservableCache()); sut.Activator.Activate(); scheduler.AdvanceBy(2); sut.Selections.Where(x => x.LoadingSettings.FilePath == "bar").Subscribe(_ => success = true); sut.SelectNext.Execute().Subscribe(); scheduler.AdvanceBy(2); Assert.True(success); });
public void ImageExplorerViewModel_SelectNextSelectsNextItem_WhenAtLeastTwoItemsAvailable() => new TestScheduler().With(scheduler => { var source = new SourceCache <ImageHandle, string>(x => x.LoadingSettings.FilePath); source.AddOrUpdate(GetDummyHandle("foo")); source.AddOrUpdate(GetDummyHandle("bar")); var sut = new ImageExplorerViewModel(source.AsObservableCache()); sut.Activator.Activate(); scheduler.AdvanceBy(2); Assert.Equal("foo", sut.SelectedItem.ExplorerItem.FilePath); sut.SelectNext.Execute().Subscribe(); scheduler.AdvanceBy(1); Assert.Equal("bar", sut.SelectedItem.ExplorerItem.FilePath); });
public UwpAccesibleFolders() { source = new SourceCache <Folder, string>(x => x.Token); Folders = source.AsObservableCache(); var folders = StorageApplicationPermissions.FutureAccessList.Entries.Select(x => new { x.Token, x.Metadata }); var enumerable = folders.Select(x => new Folder(x.Token, x.Metadata)); source.AddOrUpdate(enumerable); picker = new FolderPicker { CommitButtonText = "Select", SuggestedStartLocation = PickerLocationId.DocumentsLibrary }; picker.FileTypeFilter.Add("*"); }
public LineScroller([NotNull] IObservable<ILineProvider> latest, [NotNull] IObservable<ScrollRequest> scrollRequest) { if (latest == null) throw new ArgumentNullException(nameof(latest)); if (scrollRequest == null) throw new ArgumentNullException(nameof(scrollRequest)); var lines = new SourceCache<Line, LineKey>(l => l.Key); Lines = lines.AsObservableCache(); var locker = new object(); scrollRequest = scrollRequest.Synchronize(locker); latest = latest.Synchronize(locker); var aggregator = latest .CombineLatest(scrollRequest, (currentLines, scroll) => new { currentLines, scroll}) .Sample(TimeSpan.FromMilliseconds(50)) .Select(x => { if (x.scroll.PageSize == 0 || x.currentLines.Count == 0) return new Line[0]; return x.currentLines.ReadLines(x.scroll).ToArray(); }) .Subscribe(currentPage => { var previous = lines.Items.ToArray(); var added = currentPage.Except(previous, Line.TextStartComparer).ToArray(); var removed = previous.Except(currentPage, Line.TextStartComparer).ToArray(); lines.Edit(innerCache => { if (removed.Any()) innerCache.Remove(removed); if (added.Any()) innerCache.AddOrUpdate(added); }); }); _cleanUp = new CompositeDisposable(Lines, lines, aggregator); }
public NeuronGraphPaneViewModel(INeuronService neuronService = null) { this.neuronService = neuronService ?? Locator.Current.GetService <INeuronService>(); bool DefaultPredicate(Node <NeuronDto, int> node) => node.IsRoot; var cache = new SourceCache <NeuronDto, int>(x => x.Id); this.AddCommand = ReactiveCommand.Create(() => this.neuronService.Add(cache, NeuronService.CreateNeuron("Root Neuron", ChildType.NotSet))); this.ReloadCommand = ReactiveCommand.Create(() => { cache.Clear(); this.neuronService.Reload(cache); }); this.cleanUp = cache.AsObservableCache().Connect() .TransformToTree(child => child.ParentId, Observable.Return((Func <Node <NeuronDto, int>, bool>)DefaultPredicate)) .Transform(e => e.Item.Type == ChildType.Postsynaptic ? (NeuronViewModelBase)(new PostsynapticViewModel(e.Item.Data, e, cache)) : (NeuronViewModelBase)(new PresynapticViewModel(e.Item.Data, e, cache))) .Bind(out this.children) .DisposeMany() .Subscribe(); }
public MailBoxViewModel(IProfileDataQueryFactory queryFactory, IMailService mailService) { _queryFactory = queryFactory; _mailService = mailService; _mailFolderSelectionViewModel = new MailFolderSelectionViewModel(_sourceFolders.AsObservableCache()); var folderChanges = _sourceFolders.Connect(f => f.Type != FolderType.Root) .ObserveOn(RxApp.TaskpoolScheduler) .Sort(SortExpressionComparer <MailFolder> .Ascending(f => f.Type).ThenByAscending(f => f.Name)) .TransformToTree(f => f.ParentId) .Transform(n => new MailFolderViewModel(n, this, queryFactory, mailService)) .DisposeMany() .Publish(); folderChanges .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _allFolders) .Subscribe() .DisposeWith(_disposables); folderChanges .Filter(f => f.IsFavorite) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _favoriteFolders) .Subscribe() .DisposeWith(_disposables); folderChanges.Connect() .DisposeWith(_disposables); var folderCollection = folderChanges .ToCollection() .Publish(); folderCollection .Select(folders => folders.FirstOrDefault(f => f.Type == FolderType.Inbox)) .ObserveOn(RxApp.MainThreadScheduler) .ToPropertyEx(this, x => x.Inbox) .DisposeWith(_disposables); folderCollection.Connect() .DisposeWith(_disposables); _mailService.FolderChanges .ObserveOn(RxApp.TaskpoolScheduler) .Subscribe(changes => { _sourceFolders.Edit(updater => { foreach (var c in changes) { switch (c.State) { case DeltaState.Add: case DeltaState.Update: updater.AddOrUpdate(c.Entity); break; case DeltaState.Remove: updater.RemoveKey(c.Entity.Id); break; } } }); }) .DisposeWith(_disposables); Synchronize = ReactiveCommand.CreateFromTask(_mailService.SynchronizeFoldersAsync); //Synchronize.WithLatestFrom(folderCollection, (_, folders) => folders.Where(f => f.IsFavorite)) // .Subscribe(favoriteFolders => // { // foreach (var f in favoriteFolders) // { // f.Synchronize.Execute().Subscribe(); // } // }) // .DisposeWith(_disposables); Synchronize.ThrownExceptions .Subscribe(ex => this.Log().Error(ex)) .DisposeWith(_disposables); Synchronize.IsExecuting .ToPropertyEx(this, x => x.IsSynchronizing) .DisposeWith(_disposables); }
public IObservableCache <TAggregate, TKey> OnItemChanged() { return(_sourceCache.AsObservableCache()); }
/// <summary> /// Initializes a new instance of the <see cref="ImageEditorViewModel" /> class. /// </summary> /// <param name="imageService">Service for image loading and manipulation.</param> public ImageEditorViewModel(IImageService imageService = null) { _imageService = imageService ?? Locator.Current.GetService <IImageService>(); IObservable <ImageHandle> selectionChanges = this.WhenAnyValue(x => x.SelectedImage).Publish().RefCount(); ImageExplorer = new ImageExplorerViewModel(_source.AsObservableCache()); ImagePreview = new ImagePreviewViewModel(selectionChanges); Settings = new ImageSettingsViewModel(selectionChanges); SelectFolder = new Interaction <string, string>(); LoadImage = ReactiveCommand.CreateFromObservable <string, ImageHandle>(x => _imageService.LoadImage(x)); ExportSelected = ReactiveCommand.CreateFromObservable(ExportSelectedImpl); ExportAll = ReactiveCommand.CreateFromObservable(ExportAllImpl); _calculatePreview = ReactiveCommand.CreateFromObservable <ImageHandle, ImageHandle>(x => _imageService.CalculatePreview(x)); var connection = _source.Connect(); this.WhenActivated(d => { // Dispose handles removed from the source collection connection .DisposeMany() .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _images) .Subscribe() .DisposeWith(d); // Recaluclate image when quality changes connection.WhenPropertyChanged(x => x.ManipulationState.Quality, false) .Throttle(TimeSpan.FromMilliseconds(50)) .Select(x => x.Sender) .InvokeCommand(_calculatePreview) .DisposeWith(d); // Notify about successful export. ExportSelected .Do(name => this.Notify().PublishInfo($"Image export to {name}", "Export completed!", TimeSpan.FromSeconds(3))) .Subscribe() .DisposeWith(d); // Notify about successful export. ExportAll .Do(path => this.Notify().PublishInfo($"All images exported to {path}", "Export completed!", TimeSpan.FromSeconds(3))) .Subscribe() .DisposeWith(d); // Add loaded images to source LoadImage .ObserveOn(RxApp.TaskpoolScheduler) .Where(x => x != null) .SelectMany(x => _calculatePreview.Execute(x)) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(handle => _source.AddOrUpdate(handle)) .DisposeWith(d); // Show image loading error LoadImage.ThrownExceptions .OfType <ImageLoadingException>() .Subscribe(ex => this.Notify() .PublishError($"Sorry. \"{ex.FilePath}\" does not have a supported file format.", "Error", TimeSpan.FromSeconds(5))) .DisposeWith(d); // Pipe loadings to property Observable.CombineLatest( LoadImage.IsExecuting, ExportSelected.IsExecuting, ExportAll.IsExecuting, _calculatePreview.IsExecuting, (a, b, c, d) => a || b || c || d) .ObserveOn(RxApp.MainThreadScheduler) .ToPropertyEx(this, x => x.IsLoading) .DisposeWith(d); // React on close requests from explorer view this.WhenAnyObservable(x => x.ImageExplorer.DeletionRequests) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => _source.Remove(x)) .DisposeWith(d); // Select explorer item this.WhenAnyObservable(x => x.ImageExplorer.Selections) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => SelectedImage = x) .DisposeWith(d); }); }