/// <summary> /// Load objects tree /// </summary> /// <param name="onLoadedAction">Complete loading objects</param> /// <param name="typesFilter"> Objects type filter</param> /// <param name="ids">Id or Ids objects</param> public void Load(Action <IList <IDataObject> > onLoadedAction, Func <IType, bool> typesFilter, params Guid[] ids) { _ids = ids; _typesFilter = typesFilter; _onLoadedAction = onLoadedAction; _subscriptions.Add(_repository.SubscribeObjects(ids).Subscribe(this)); }
private void StartLoad() { _toLoad.Add(_sourceId); _repository.SubscribeObjects(new List <Guid> { _sourceId }).Subscribe(this); }
public void Load(Action <IList <IDataObject> > onLoadedAction, params Guid[] ids) { _objects = new List <IDataObject>(); _ids = ids; _onLoadedAction = onLoadedAction; _subscription = _repository.SubscribeObjects(ids).Subscribe(this); }
public void Load(ICollection <Guid> ids, Action <List <IDataObject> > onLoadedAction) { _onLoadedAction = onLoadedAction; _count = ids.Count(); _list = new List <IDataObject>(); _subscription = _repository.SubscribeObjects(ids).Subscribe(this); _subscription.Dispose(); }
public void Load(IEnumerable <Guid> ids) { var disposable = _repository.SubscribeObjects(ids) .Where(x => x.State == DataState.Loaded) .SubscribeOnDispatcher(DispatcherPriority.Background) .Subscribe(o => { var dataObject = new DataObject(o.Id, o.ParentId, o.DisplayName, o.Type.SvgIcon, o.Type.Sort, o.Children); _dataObjects.AddOrUpdate(dataObject); }); _cleanUp.Add(disposable); }
public void Load(Guid id, Action nothingLoaded, bool isAddParent) { var disposable = _repository.SubscribeObjects(new [] { id }) .Where(x => _childrenFilter.Filter(x)) .SubscribeOnDispatcher(DispatcherPriority.Background) .Subscribe(o => { var children = _childrenFilter.ChildrenFilter(o).ToList(); if (children.Count == 0) { nothingLoaded(); return; } if (isAddParent) { _dataObjects.AddOrUpdate(o); } Load(children); }); _cleanUp.Add(disposable); }
/// <summary> /// Returns objects by identifiers as an asynchronous operation /// </summary> /// <typeparam name="T">Type of extension-side IDataObject projection</typeparam> /// <param name="ids">Object identifiers to be loaded</param> /// <param name="converter">Сonverts IDataObject to the extension-side projection. /// IDataObject belongs to the application AppDomain and can be used for 2 minutes only after being created, /// so it should be converted to the extension-side projection immedeately after being received.</param> /// <param name="ct">CancellationToken to cancel objects loading. The OperationCanceledException will be thrown.</param> /// <returns>The task object representing the asynchronous operation</returns> public Task <IEnumerable <T> > GetObjectsAsync <T>(IEnumerable <Guid> ids, Func <IDataObject, T> converter, CancellationToken ct) { // Creates an observable that fires notification when cancelling CancellationToken var cancel = Observable.Create <T>(o => ct.Register(o.OnCompleted)); var loading = ids.ToList(); var observableList = _repository .SubscribeObjects(loading) // Subscribing on interested objects .TakeUntil(cancel) // Stopping subscription on cancel .Where(o => o.State == DataState.Loaded) // Filtering "NoData" notifications .Distinct(o => o.Id) // Filtering already emitted notifications .Select(converter) // Converting IDataObject to extension-side projection .Take(loading.Count) // Wait for all objects to be loaded .ToList(); return(Task <IEnumerable <T> > .Factory.StartNew(() => { var lazy = observableList.Wait(); // Forces the "lazy" enumerable to be immedeately iterated in background thread return lazy.ToList(); }, ct)); }
public void Load(Guid id, Action <IDataObject> onLoadedAction) { _loaded = false; _onLoadedAction = onLoadedAction; _subscription = _repository.SubscribeObjects(new[] { id }).Subscribe(this); }