public void ReactiveCommandAllFlow()
{
var testScheduler = new TestScheduler();
var @null = (object)null;
var recorder1 = testScheduler.CreateObserver <object>();
var recorder2 = testScheduler.CreateObserver <object>();
var cmd = new ReactiveCommand();
cmd.Subscribe(recorder1);
cmd.Subscribe(recorder2);
cmd.CanExecute().Is(true);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Dispose();
cmd.CanExecute().Is(false);
cmd.Dispose(); // dispose again
recorder1.Messages.Is(
OnNext(0, @null),
OnNext(10, @null),
OnNext(20, @null),
OnCompleted <object>(30));
recorder2.Messages.Is(
OnNext(0, @null),
OnNext(10, @null),
OnNext(20, @null),
OnCompleted <object>(30));
}
public void ReactiveCommandAllFlow()
{
var testScheduler = new TestScheduler();
var @null = (object)null;
var recorder1 = testScheduler.CreateObserver<object>();
var recorder2 = testScheduler.CreateObserver<object>();
var cmd = new ReactiveCommand();
cmd.Subscribe(recorder1);
cmd.Subscribe(recorder2);
cmd.CanExecute().Is(true);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Execute(); testScheduler.AdvanceBy(10);
cmd.Dispose();
cmd.CanExecute().Is(false);
cmd.Dispose(); // dispose again
recorder1.Messages.Is(
OnNext(0, @null),
OnNext(10, @null),
OnNext(20, @null),
OnCompleted<object>(30));
recorder2.Messages.Is(
OnNext(0, @null),
OnNext(10, @null),
OnNext(20, @null),
OnCompleted<object>(30));
}
public void Reset()
{
_imageManager = null;
if (_rotateCommand != null)
{
_rotateCommand.Dispose();
_rotateCommand = null;
this.RaisePropertyChanged("RotateCommand");
}
}
public void Dispose()
{
if (_beginInsertCommand != null)
{
_beginInsertCommand.Dispose();
_beginInsertCommand = null;
}
if (_applyInsertCommand != null)
{
_applyInsertCommand.Dispose();
_applyInsertCommand = null;
}
if (_cancelAddingCommand != null)
{
_cancelAddingCommand.Dispose();
_cancelAddingCommand = null;
}
if (_removeDocumentCommand != null)
{
_removeDocumentCommand.Dispose();
_removeDocumentCommand = null;
}
_disposableObject.Dispose();
HasDocument = null;
_disposedNotification.OnNext(Unit.Default);
}
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
if (disposing)
{
_innerCommand.Dispose();
_exceptions.Dispose();
_exceptionsSubscription.Dispose();
}
}
protected override void OnEditableObjectChanging(TEditObject oldObject, TEditObject newObject)
{
if (_applyCommand != null)
{
_applyCommand.Dispose();
_applyCommand = null;
this.RaisePropertyChanged("ApplyCommand");
}
}
public void CanExecuteIsUnsubscribedAfterCommandDisposal()
{
Subject <bool> canExecuteSubject = new Subject <bool>();
ReactiveCommand <Unit, IObservable <Unit> > fixture = ReactiveCommand.Create(() => Observables.Unit, canExecuteSubject, ImmediateScheduler.Instance);
Assert.True(canExecuteSubject.HasObservers);
fixture.Dispose();
Assert.False(canExecuteSubject.HasObservers);
}
public override void OnNavigatedFrom(Dictionary <string, object> viewModelState, bool suspending)
{
// The base implementation uses RestorableStateAttribute and Reflection to save and restore state
// If you do not use this attribute, do not invoke base impkementation to prevent execution this useless code.
if (!suspending)
{
if (_signInCommand != null)
{
_signInCommand.Dispose();
}
}
}
public void Dispose()
{
if (_scanningCommand != null)
{
_scanningCommand.Dispose();
_scanningCommand = null;
}
if (_fromFileSystemCommand != null)
{
_fromFileSystemCommand.Dispose();
_fromFileSystemCommand = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_isEditingSub.Dispose();
_activeToolSub.Dispose();
_undoCommand.Dispose();
_rectCommand.Dispose();
_lineCommand.Dispose();
_ellipseCommand.Dispose();
_freeDrawCommand.Dispose();
_isEditingSub = null;
_activeToolSub = null;
_undoCommand = null;
_rectCommand = null;
_lineCommand = null;
_ellipseCommand = null;
_freeDrawCommand = null;
}
}
public LogEntryViewer(ILogEntryService logEntryService)
{
//build an observable filter
var filter = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//filter, sort and populate reactive list.
var shared = logEntryService.Items.Connect()
.Transform(le => new LogEntryProxy(le))
.DelayRemove(TimeSpan.FromSeconds(0.75), proxy => proxy.FlagForRemove())
.Publish();
var loader = shared.Filter(filter)
.Sort(SortExpressionComparer <LogEntryProxy> .Descending(le => le.TimeStamp).ThenByDescending(l => l.Key), SortOptions.UseBinarySearch)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out var data)
.DisposeMany()
.Subscribe();
Data = data;
//aggregate total items
var summariser = shared.QueryWhenChanged(items =>
{
var debug = items.Count(le => le.Level == LogLevel.Debug);
var info = items.Count(le => le.Level == LogLevel.Info);
var warn = items.Count(le => le.Level == LogLevel.Warning);
var error = items.Count(le => le.Level == LogLevel.Error);
return(new LogEntrySummary(debug, info, warn, error));
})
.Subscribe(s => Summary = s);
//manage user selection, delete items command
var selectedItems = _selectionController.SelectedItems.Connect().Publish();
//Build a message from selected items
_deleteItemsText = selectedItems.QueryWhenChanged(query =>
{
if (query.Count == 0)
{
return("Select log entries to delete");
}
if (query.Count == 1)
{
return("Delete selected log entry?");
}
return($"Delete {query.Count} log entries?");
})
.ToProperty(this, viewmodel => viewmodel.DeleteItemsText, "Select log entries to delete");
//make a command out of selected items - enabling the command when there is a selection
DeleteCommand = ReactiveCommand.Create(() =>
{
var toRemove = _selectionController.SelectedItems.Items.Select(proxy => proxy.Original).ToArray();
_selectionController.Clear();
logEntryService.Remove(toRemove);
}, selectedItems.QueryWhenChanged(query => query.Count > 0));
var connected = selectedItems.Connect();
var connectedItems = shared.Connect();
_cleanUp = Disposable.Create(() =>
{
loader.Dispose();
connected.Dispose();
_deleteItemsText.Dispose();
DeleteCommand.Dispose();
_selectionController.Dispose();
summariser.Dispose();
connectedItems.Dispose();
});
}
public LogEntryViewer(ILogEntryService logEntryService)
{
_logEntryService = logEntryService;
//apply filter when search text has changed
var filterApplier = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(_filter.Change);
//filter, sort and populate reactive list.
var loader = logEntryService.Items.Connect()
.Transform(le => new LogEntryProxy(le))
.DelayRemove(TimeSpan.FromSeconds(0.75), proxy =>
{
proxy.FlagForRemove();
_selectionController.DeSelect(proxy);
})
.Filter(_filter)
.Sort(SortExpressionComparer <LogEntryProxy> .Descending(le => le.TimeStamp).ThenByDescending(l => l.Key), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_data)
.DisposeMany()
.Subscribe();
//aggregate total items
var summariser = logEntryService.Items.Connect()
.QueryWhenChanged(query =>
{
var items = query.Items.ToList();
var debug = items.Count(le => le.Level == LogLevel.Debug);
var info = items.Count(le => le.Level == LogLevel.Info);
var warn = items.Count(le => le.Level == LogLevel.Warning);
var error = items.Count(le => le.Level == LogLevel.Error);
return(new LogEntrySummary(debug, info, warn, error));
})
.Subscribe(s => Summary = s);
//manage user selection, delete items command
var selectedItems = _selectionController.SelectedItems.Connect().Publish();
//Build a message from selected items
_deleteItemsText = selectedItems.QueryWhenChanged(query =>
{
if (query.Count == 0)
{
return("Select log entries to delete");
}
if (query.Count == 1)
{
return("Delete selected log entry?");
}
return(string.Format("Delete {0} log entries?", query.Count));
})
.ToProperty(this, viewmodel => viewmodel.DeleteItemsText, "Select log entries to delete");
//make a command out of selected items - enabling the command when there is a selection
_deleteCommand = selectedItems
.QueryWhenChanged(query => query.Count > 0)
.ToCommand();
//Assign action when the command is invoked
var commandInvoker = this.WhenAnyObservable(x => x.DeleteCommand)
.Subscribe(_ =>
{
var toRemove = _selectionController.SelectedItems.Items.Select(proxy => proxy.Key).ToArray();
_logEntryService.Remove(toRemove);
});
var connected = selectedItems.Connect();
_cleanUp = Disposable.Create(() =>
{
loader.Dispose();
filterApplier.Dispose();
_filter.Dispose();
connected.Dispose();
_deleteItemsText.Dispose();
_deleteCommand.Dispose();
commandInvoker.Dispose();
_selectionController.Dispose();
summariser.Dispose();
});
}
public LogEntryViewer(ILogEntryService logEntryService)
{
_logEntryService = logEntryService;
//build an observable filter
var filter = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//filter, sort and populate reactive list.
var loader = logEntryService.Items.Connect()
.Transform(le => new LogEntryProxy(le))
.DelayRemove(TimeSpan.FromSeconds(0.75), proxy =>proxy.FlagForRemove())
.Filter(filter)
.Sort(SortExpressionComparer<LogEntryProxy>.Descending(le=>le.TimeStamp).ThenByDescending(l => l.Key),SortOptions.UseBinarySearch)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_data)
.DisposeMany()
.Subscribe();
//aggregate total items
var summariser = logEntryService.Items.Connect()
.QueryWhenChanged(items =>
{
var debug = items.Count(le => le.Level == LogLevel.Debug);
var info = items.Count(le => le.Level == LogLevel.Info);
var warn = items.Count(le => le.Level == LogLevel.Warning);
var error = items.Count(le => le.Level == LogLevel.Error);
return new LogEntrySummary(debug, info, warn, error);
})
.Subscribe(s => Summary = s);
//manage user selection, delete items command
var selectedItems = _selectionController.SelectedItems.Connect().Publish();
//Build a message from selected items
_deleteItemsText = selectedItems.QueryWhenChanged(query =>
{
if (query.Count == 0) return "Select log entries to delete";
if (query.Count == 1) return "Delete selected log entry?";
return string.Format("Delete {0} log entries?", query.Count);
})
.ToProperty(this, viewmodel => viewmodel.DeleteItemsText, "Select log entries to delete");
//make a command out of selected items - enabling the command when there is a selection
_deleteCommand = selectedItems
.QueryWhenChanged(query => query.Count > 0)
.ToCommand();
//Assign action when the command is invoked
var commandInvoker = this.WhenAnyObservable(x => x.DeleteCommand)
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(_ =>
{
var toRemove = _selectionController.SelectedItems.Items.Select(proxy => proxy.Original).ToArray();
_selectionController.Clear();
_logEntryService.Remove(toRemove);
});
var connected = selectedItems.Connect();
_cleanUp= Disposable.Create(() =>
{
loader.Dispose();
connected.Dispose();
_deleteItemsText.Dispose();
_deleteCommand.Dispose();
commandInvoker.Dispose();
_selectionController.Dispose();
summariser.Dispose();
});
}
