/// <summary> /// Initializes a new instance of the <see cref="ViewModelViewHost"/> class. /// </summary> public ViewModelViewHost() { _currentView = new SerialDisposable(); _viewContract = this .WhenAnyObservable(x => x.ViewContractObservable !) .ToProperty(this, x => x.ViewContract, initialValue: null, scheduler: RxApp.MainThreadScheduler); Initialize(); }
public ViewModelViewHost() { this.currentView = new SerialDisposable(); this.viewContract = this .WhenAnyObservable(x => x.ViewContractObservable) .ToProperty(this, x => x.ViewContract, scheduler: RxApp.MainThreadScheduler); this.Initialize(); }
public static void AssignSameTwiceDoesNotDispose() { using var serialDisposable = new SerialDisposable <IDisposable>(); var mock = new Mock <IDisposable>(MockBehavior.Strict); serialDisposable.Disposable = mock.Object; serialDisposable.Disposable = mock.Object; mock.Setup(x => x.Dispose()); }
public ToDoItemView() { InitializeComponent(); var disposable = new SerialDisposable(); this.OnUpdated <ToDoItem>(viewModel => { IDisposable buttonClick, userTyped; // TODO: need a cancel button here if (viewModel.IsEditable) { editButton.Visibility = Visibility.Collapsed; saveButton.Visibility = Visibility.Visible; buttonClick = Observable.FromEventPattern <RoutedEventArgs>(saveButton, "Click") .Subscribe(_ => this.Dispatch(new SaveItemAction(viewModel.Id, edit.Text))); userTyped = edit.Events().KeyDown .Where(x => x.Key == Key.Enter) .SelectUnit() .Subscribe(_ => this.Dispatch(new SaveItemAction(viewModel.Id, edit.Text))); edit.Visibility = Visibility.Visible; text.Visibility = Visibility.Collapsed; } else { editButton.Visibility = Visibility.Visible; saveButton.Visibility = Visibility.Collapsed; buttonClick = Observable.FromEventPattern <RoutedEventArgs>(editButton, "Click") .Subscribe(_ => this.Dispatch(new EditItemAction(viewModel.Id))); userTyped = Disposable.Empty; edit.Visibility = Visibility.Collapsed; text.Visibility = Visibility.Visible; } text.Text = viewModel.Text; edit.Text = viewModel.Text; isChecked.IsChecked = viewModel.IsComplete; var checkedChanged = isChecked.IsChecked == false ? Observable.FromEventPattern <RoutedEventArgs>(isChecked, "Checked") .Subscribe(_ => this.Dispatch(new CheckedItemAction(viewModel.Id))) : Observable.FromEventPattern <RoutedEventArgs>(isChecked, "Unchecked") .Subscribe(_ => this.Dispatch(new UncheckedItemAction(viewModel.Id))); disposable.Disposable = new CompositeDisposable(buttonClick, userTyped, checkedChanged); }); }
public MainViewModel(IDiagnosticsViewModel diagnosticsViewModel, ITabularDataService tabularDataService, IColumnsService columnsService, IOverlayService overlayService, IDateTimeService dateTimeService, ISchedulerService schedulerService) { _tabularDataService = tabularDataService; _schedulerService = schedulerService; _columnsService = columnsService; _overlayService = overlayService; _dateTimeService = dateTimeService; Diagnostics = diagnosticsViewModel; _dataIds = new Dictionary <object, DynamicDataViewModel>(1000); _data = new CustomTypeRangeObservableCollection <DynamicDataViewModel>(); _collectionView = new ListCollectionView(_data) { Filter = FilterData }; _updateStats = new Dictionary <long, int>(); RefreshCommand = ReactiveCommand.Create() .DisposeWith(this); ClearCommand = ReactiveCommand.Create() .DisposeWith(this); ColumnPickerCommand = ReactiveCommand.Create(HasDataChanged) .DisposeWith(this); _dataStream = InitialiseAndProcessDataAsync() .DisposeWith(this); RefreshCommand.Subscribe(x => Refresh()) .DisposeWith(this); ClearCommand.Subscribe(x => Clear()) .DisposeWith(this); ColumnPickerCommand.Subscribe(x => ShowColumnPicker()) .DisposeWith(this); _suspendNotifications = new SerialDisposable() .DisposeWith(this); FilterChanged.Subscribe(x => _collectionView.Refresh()) .DisposeWith(this); ColumnsChanged.ObserveOn(schedulerService.Dispatcher) .Subscribe(x => OnPropertyChanged(nameof(VisibleColumns))) .DisposeWith(this); Disposable.Create(() => Clear()) .DisposeWith(this); }
public override IDisposable Subscribe(IObserver <T[]> observer) { this.observer = observer; disposable = _serialDisposable = new SerialDisposable(); var group = _batched[_index]; _serialDisposable.Disposable = group.Subscribe(this); return(_serialDisposable); }
void Restart() { Debug.Log("Restart"); disposable.Dispose(); disposable = new SerialDisposable(); disposable.Disposable = Observable.Interval(TimeSpan.FromSeconds(interval)).Subscribe(_ => SendObsData() ).AddTo(this); }
public static Func <IDisposable> CreateAndDisposeOn(this Func <IDisposable> fn, IScheduler s) { return(() => { var d = new SerialDisposable(); s.Schedule(() => d.Disposable = fn()); return d.DisposeOn(s); }); }
public Character(Dungeon _dungeon) { UniqueId = lastId++; ActionWait = MAX_WAIT; dungeon = _dungeon; ReservedActions = new List <CharacterAction>(); spriteAnimationDisposable = new SerialDisposable(); StatusEffects = new List <CharacterStatusEffect>(); }
public IDisposable Run() { sourceSubscription = new SingleAssignmentDisposable(); timerSubscription = new SerialDisposable(); timerSubscription.Disposable = RunTimer(objectId); sourceSubscription.Disposable = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(timerSubscription, sourceSubscription)); }
public ComplexClass() { SerialDisposable = new SerialDisposable(); MethodModel = new ThreeMethodsWithMultipleSubscribesModel(); Subject = new Subject <string>(); DisposableTestContainer.Add( this.WhenAnyValue(x => x.StringProperty).Subscribe()); }
public IDisposable Run() { tick = new ThrottleFirstFrameTick(this); cancelable = new SerialDisposable(); var subscription = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(cancelable, subscription)); }
public static IObservable <TSource> CatchAndRetry <TSource, TException>( this IObservable <TSource> source, Func <TException /* error */, IObservable <TSource> /* originalSource */, int /* failureCount */, IObservable <TSource> > delayFactory, IScheduler scheduler = null ) where TException : Exception { return(Observable.Create <TSource>(observer => { scheduler = scheduler ?? Scheduler.CurrentThread; var originalScoure = source; var sourceDisposable = new SerialDisposable(); int retryCount = 0; var scheduleDisposable = scheduler.Schedule( self => { var oldSubscription = sourceDisposable.Disposable; var newSubscription = source.Subscribe( onNext: x => { observer.OnNext(x); if (retryCount > 0) { retryCount = 0; } }, onError: ex => { var typedException = ex as TException; if (typedException != null) { source = delayFactory(typedException, originalScoure, ++retryCount); if (source != null) { self(); } else { observer.OnError(ex); } } else { observer.OnError(ex); } }, onCompleted: observer.OnCompleted ); if (sourceDisposable.Disposable == oldSubscription) { sourceDisposable.Disposable = newSubscription; } }); return new CompositeDisposable(scheduleDisposable, sourceDisposable); })); }
/// <summary> /// Set the source URI of the image. /// </summary> /// <param name="view">The image view instance.</param> /// <param name="source">The source URI.</param> private async void SetUriFromSingleSource(Border view, string source) { var imageBrush = (ImageBrush)view.Background; var tag = view.GetTag(); var disposable = default(SerialDisposable); if (!_disposables.TryGetValue(tag, out disposable)) { disposable = new SerialDisposable(); _disposables.Add(tag, disposable); } var image = new BitmapImage(); if (BitmapImageHelpers.IsBase64Uri(source)) { image.BeginInit(); image.CacheOption = BitmapCacheOption.OnLoad; disposable.Disposable = image.GetStreamLoadObservable().Subscribe( status => OnImageStatusUpdate(view, status), _ => OnImageFailed(view)); var stream = BitmapImageHelpers.GetStreamAsync(source); image.StreamSource = stream; image.EndInit(); } else { try { var uri = new Uri(source); image.BeginInit(); image.CacheOption = BitmapCacheOption.OnLoad; if (uri.IsFile) { image.UriSource = uri; } else { await SetImageSourceFromUri(uri, image); } image.EndInit(); } catch (Exception) { image = null; } } imageBrush.ImageSource = image; }
public static T DisposeWith <T>(this T obj, SerialDisposable serialDisposable) { var disposable = obj as IDisposable; if (disposable != null) { serialDisposable.Disposable = disposable; } return(obj); }
public IDisposable Run() { list = new List <T>(); timerId = 0L; timerD = new SerialDisposable(); CreateTimer(); IDisposable disposable = parent.source.Subscribe(this); return(StableCompositeDisposable.Create(disposable, timerD)); }
public IDisposable Run() { cancelable = new SerialDisposable(); var subscription = parent.source.Subscribe(this); messageQueue = new Queue<T>(10); MainThreadDispatcher.SendStartCoroutine(TakeCoroutine()); return StableCompositeDisposable.Create(cancelable, subscription); }
protected override IDisposable SubscribeCore(IObserver <long> observer, IDisposable cancel) { var timerObserver = new Timer(observer, cancel); var dueTime = (dueTimeA != null) ? dueTimeA.Value - scheduler.Now : dueTimeB.Value; // one-shot if (period == null) { return(scheduler.Schedule(Scheduler.Normalize(dueTime), () => { timerObserver.OnNext(); timerObserver.OnCompleted(); })); } else { var periodicScheduler = scheduler as ISchedulerPeriodic; if (periodicScheduler != null) { if (dueTime == period.Value) { // same(Observable.Interval), run periodic return(periodicScheduler.SchedulePeriodic(Scheduler.Normalize(dueTime), timerObserver.OnNext)); } else { // Schedule Once + Scheudle Periodic var disposable = new SerialDisposable(); disposable.Disposable = scheduler.Schedule(Scheduler.Normalize(dueTime), () => { timerObserver.OnNext(); // run first var timeP = Scheduler.Normalize(period.Value); disposable.Disposable = periodicScheduler.SchedulePeriodic(timeP, timerObserver.OnNext); // run periodic }); return(disposable); } } else { var timeP = Scheduler.Normalize(period.Value); return(scheduler.Schedule(Scheduler.Normalize(dueTime), self => { timerObserver.OnNext(); self(timeP); })); } } }
/// <summary> /// Set the source URI of the image. /// </summary> /// <param name="view">The image view instance.</param> /// <param name="source">The source URI.</param> private async void SetUriFromSingleSource(Border view, string source) { var imageBrush = (ImageBrush)view.Background; var tag = view.GetTag(); var disposable = default(SerialDisposable); if (!_disposables.TryGetValue(tag, out disposable)) { disposable = new SerialDisposable(); _disposables.Add(tag, disposable); } if (BitmapImageHelpers.IsBase64Uri(source)) { var image = new BitmapImage(); disposable.Disposable = image.GetStreamLoadObservable().Subscribe( status => OnImageStatusUpdate(view, status.LoadStatus, status.Metadata), _ => OnImageFailed(view)); using (var stream = await BitmapImageHelpers.GetStreamAsync(source)) { await image.SetSourceAsync(stream); } imageBrush.ImageSource = image; } else if (BitmapImageHelpers.IsHttpUri(source)) { OnImageStatusUpdate(view, ImageLoadStatus.OnLoadStart, default(ImageMetadata)); try { var image = await ImageCache.Instance.GetFromCacheAsync(new Uri(source), true); var metadata = new ImageMetadata(source, image.PixelWidth, image.PixelHeight); OnImageStatusUpdate(view, ImageLoadStatus.OnLoad, metadata); imageBrush.ImageSource = image; OnImageStatusUpdate(view, ImageLoadStatus.OnLoadEnd, metadata); } catch { OnImageFailed(view); } } else { var image = new BitmapImage(); disposable.Disposable = image.GetUriLoadObservable().Subscribe( status => OnImageStatusUpdate(view, status.LoadStatus, status.Metadata), _ => OnImageFailed(view)); image.UriSource = new Uri(source); imageBrush.ImageSource = image; } }
public void WhereIndex_DisposeInPredicate() { var scheduler = new TestScheduler(); var invoked = 0; var xs = scheduler.CreateHotObservable( OnNext(110, 1), OnNext(180, 2), OnNext(230, 3), OnNext(270, 4), OnNext(340, 5), OnNext(380, 6), OnNext(390, 7), OnNext(450, 8), OnNext(470, 9), OnNext(560, 10), OnNext(580, 11), OnCompleted<int>(600), OnNext(610, 12), OnError<int>(620, new Exception()), OnCompleted<int>(630) ); var res = scheduler.CreateObserver<int>(); var d = new SerialDisposable(); var ys = default(IObservable<int>); scheduler.ScheduleAbsolute(Created, () => ys = xs.Where((x, i) => { invoked++; if (x == 8) d.Dispose(); return IsPrime(x + i * 10); })); scheduler.ScheduleAbsolute(Subscribed, () => d.Disposable = ys.Subscribe(res)); scheduler.ScheduleAbsolute(Disposed, () => d.Dispose()); scheduler.Start(); res.Messages.AssertEqual( OnNext(230, 3), OnNext(390, 7) ); xs.Subscriptions.AssertEqual( Subscribe(200, 450) ); Assert.Equal(6, invoked); }
public BubbleViewModel(int initialExponent, Vector2Int gridPosition) { _gridPosition = new ReactiveProperty <Vector2Int>(gridPosition).AddTo(Disposer); _exponent = new ReactiveProperty <int>(initialExponent).AddTo(Disposer); _isOnGrid = new ReactiveProperty <bool>(true).AddTo(Disposer); _nextBubbleIndex = new ReactiveProperty <int>(-1).AddTo(Disposer); _mergeTarget = new ReactiveProperty <Vector2Int>(new Vector2Int(-1, -1)).AddTo(Disposer); _serialDisposable = new SerialDisposable().AddTo(Disposer); _isConnectedToCeiling = new ReactiveProperty <bool>().AddTo(Disposer); _neighborAdded = new ReactiveProperty <Vector2Int>().AddTo(Disposer); }
public GoogleDriveExerciseDocumentService( IConnectionResultHandler connectionResultHandler) { Ensure.ArgumentNotNull(connectionResultHandler, nameof(connectionResultHandler)); this.logger = LoggerService.GetLogger(this.GetType()); this.connectionResultHandler = connectionResultHandler; this.exerciseDocument = new BehaviorSubject <string>(null); this.sync = new object(); this.connectedDisposable = new SerialDisposable(); }
public static IDisposable BindTo(this IObservable <bool> This, IInputLayer inputLayer, string reason) { var disableDisposable = new SerialDisposable(); return(new CompositeDisposable( disableDisposable, This.DistinctUntilChanged() .Subscribe(x => disableDisposable.Disposable = x ? null : inputLayer.Disable(reason)))); }
public IDisposable Schedule <TState>(TState state, Func <IScheduler, TState, IDisposable> action) { bool isCancelled = false; var innerDisp = new SerialDisposable { Disposable = Disposable.Empty }; try { if (looperId > 0 && looperId == Java.Lang.Thread.CurrentThread().Id) { return(action(this, state)); } } catch (Exception exception) { analyticsService.DebugScheduleError.Track(nameof(HandlerScheduler), "Schedule:1:1", exception.GetType().Name, exception.StackTrace); analyticsService.Track(exception, exception.Message); throw; } try { handler.Post(() => { if (isCancelled) { return; } try { innerDisp.Disposable = action(this, state); } catch (Exception exception) { analyticsService.DebugScheduleError.Track(nameof(HandlerScheduler), "Schedule:1:2", exception.GetType().Name, exception.StackTrace); analyticsService.Track(exception, exception.Message); throw; } }); } catch (Exception exception) { analyticsService.DebugScheduleError.Track(nameof(HandlerScheduler), "Schedule:1:3", exception.GetType().Name, exception.StackTrace); analyticsService.Track(exception, exception.Message); throw; } return(new CompositeDisposable( Disposable.Create(() => isCancelled = true), innerDisp )); }
public void AssignNull() { int i = 0; var d = new SerialDisposable(); d.Disposable = Disposable.Create(() => i++); d.Disposable = null; // this disposes previous disposable. d.Dispose(); Assert.IsTrue(d.IsDisposed, "#1"); Assert.AreEqual(1, i, "#2"); }
public static void DisposesOnAssignWhenDisposed() { using var serialDisposable = new SerialDisposable <IDisposable>(); #pragma warning disable IDISP016, IDISP017 // Don't use disposed instance. serialDisposable.Dispose(); #pragma warning restore IDISP016, IDISP017 // Don't use disposed instance. var mock = new Mock <IDisposable>(MockBehavior.Strict); mock.Setup(x => x.Dispose()); serialDisposable.Disposable = mock.Object; mock.Verify(x => x.Dispose(), Times.Once); }
public void Serial() { var d = new SerialDisposable(); d.IsDisposed.IsFalse(); var id1 = new IdDisp(1); var id2 = new IdDisp(2); var id3 = new IdDisp(3); // dispose first d.Dispose(); d.IsDisposed.IsTrue(); d.Disposable = id1; id1.IsDisposed.IsTrue(); d.Disposable = id2; id2.IsDisposed.IsTrue(); d.Disposable = id3; id3.IsDisposed.IsTrue(); // normal flow d = new SerialDisposable(); id1 = new IdDisp(1); id2 = new IdDisp(2); id3 = new IdDisp(3); d.Disposable = id1; id1.IsDisposed.IsFalse(); d.Dispose(); id1.IsDisposed.IsTrue(); d.Disposable = id2; id2.IsDisposed.IsTrue(); d.Disposable = id3; id3.IsDisposed.IsTrue(); // exception flow d = new SerialDisposable(); id1 = new IdDisp(1); id2 = new IdDisp(2); id3 = new IdDisp(3); d.Disposable = id1; id1.IsDisposed.IsFalse(); d.Disposable = id2; id1.IsDisposed.IsTrue(); id2.IsDisposed.IsFalse(); d.Disposable = id3; id2.IsDisposed.IsTrue(); id3.IsDisposed.IsFalse(); d.Dispose(); id3.IsDisposed.IsTrue(); // null d = new SerialDisposable(); id1 = new IdDisp(1); d.Disposable = null; d.Dispose(); d.Disposable = null; }
public SavegameService( SavegamesConfig savegamesConfig, IDataStorageStrategy dataStorageStrategy) { _savegamesConfig = savegamesConfig; _dataStorageStrategy = dataStorageStrategy; _savegameDisposer = new SerialDisposable().AddTo(Disposer); _saveDisposer = new SerialDisposable().AddTo(Disposer); _requestSaveTimeout = TimeSpan.FromSeconds(_savegamesConfig.RequestSaveTimeoutSeconds); }
public Grid() : base() { _rowDefinitions = new RowDefinitionCollection(this); _columnDefinitions = new ColumnDefinitionCollection(this); _subscriptions = new SerialDisposable(); _rowSubscriptions = new SerialDisposable(); _columnSubscriptions = new SerialDisposable(); Children.CollectionChanged += Children_CollectionChanged; }
public void DisposesOnAssignWhenDisposed() { using (var serialDisposable = new SerialDisposable <IDisposable>()) { serialDisposable.Dispose(); var mock = new Mock <IDisposable>(MockBehavior.Strict); mock.Setup(x => x.Dispose()); serialDisposable.Disposable = mock.Object; mock.Verify(x => x.Dispose(), Times.Once); } }