public TodoAppContext()
{
this.doneItems = this.AllItems
.ToFilteredReadOnlyObservableCollection(x => x.Done);
this.todoItems = this.AllItems
.ToFilteredReadOnlyObservableCollection(x => !x.Done);
this.AllItems
.ObserveElementProperty(x => x.Done, isPushCurrentValueAtFirst: false)
.Subscribe(async _ => await this.SaveAsync());
}
public TodoAppContext()
{
this.doneItems = this.AllItems
.ToFilteredReadOnlyObservableCollection(x => x.Done);
this.todoItems = this.AllItems
.ToFilteredReadOnlyObservableCollection(x => !x.Done);
this.AllItems
.ObserveElementProperty(x => x.Done, isPushCurrentValueAtFirst: false)
.Subscribe(async _ => await this.SaveAsync());
}
public MainPageViewModel()
{
var source = new ObservableCollection<Item>();
this.Items = source.ToFilteredReadOnlyObservableCollection(_ => true);
var timer = new DispatcherTimer();
timer.Tick += (_, __) =>
{
source.Add(new Item { Value = "item" + source.Count });
};
timer.Interval = TimeSpan.FromSeconds(1);
timer.Start();
}
public CollectionsViewModel()
{
AddToReactiveCollectionCommand = new ReactiveCommand()
.AddTo(Disposables);
ReactiveCollection = AddToReactiveCollectionCommand
.Select(_ => Guid.NewGuid())
.ToReactiveCollection()
.AddTo(Disposables);
ClearReactiveCollectionCommand = new ReactiveCommand()
.AddTo(Disposables);
ClearReactiveCollectionCommand.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(_ =>
{
ReactiveCollection.ClearOnScheduler();
});
GuidViewModels = _model.Guids
.ToReadOnlyReactiveCollection(x => new GuidViewModel(x))
.AddTo(Disposables);
AddGuidToModelCommand = new ReactiveCommand()
.AddTo(Disposables);
AddGuidToModelCommand.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(_ => _model.Guids.Add(Guid.NewGuid()))
.AddTo(Disposables);
ClearModelGuidsCommand = new ReactiveCommand()
.AddTo(Disposables);
ClearModelGuidsCommand.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(_ => _model.Guids.Clear())
.AddTo(Disposables);
FilterSourceItems = new ObservableCollection <FilterSourceItem>();
FilteredItems = FilterSourceItems
.ToFilteredReadOnlyObservableCollection(x => x.Count >= 7)
.AddTo(Disposables);
AddToFilterSourceItemsCommand = new ReactiveCommand()
.WithSubscribe(() => FilterSourceItems.Add(new FilterSourceItem()))
.AddTo(Disposables);
ClearFromFilterSourceItemsCommand = FilterSourceItems.ObserveProperty(x => x.Count)
.Select(x => x != 0)
.ToReactiveCommand()
.WithSubscribe(() =>
{
foreach (var d in FilterSourceItems)
{
d.Dispose();
}
FilterSourceItems.Clear();
})
.AddTo(Disposables);
}
public IFilteredReadOnlyObservableCollection1ViewModel()
{
AddCommand = new ReactiveCommand().AddTo(CompositeDisposable);
ClearCommand = new ReactiveCommand().AddTo(CompositeDisposable);
SourceValues = AddCommand
.Select(_ => new ValueHolder(SourceValues.Count))
.ToReadOnlyReactiveCollection(onReset: ClearCommand.ToUnit())
.AddTo(CompositeDisposable);
FilteredValues = SourceValues
.ToFilteredReadOnlyObservableCollection(x => (x.Value % 3) == 0)
.AddTo(CompositeDisposable);
}
public MainPageViewModel()
{
var source = new ObservableCollection <Item>();
this.Items = source.ToFilteredReadOnlyObservableCollection(_ => true);
var timer = new DispatcherTimer();
timer.Tick += (_, __) =>
{
source.Add(new Item {
Value = "item" + source.Count
});
};
timer.Interval = TimeSpan.FromSeconds(1);
timer.Start();
}
public MainWindowViewModel()
{
// IFilteredReadOnlyObservableCollectionを使うためにTypeをReactivePropertySlimで包んでいる。
// 選んだ理由はINotifyPropertyChangedを実装しているからで、それ以上の意味はない。
var rc = new ReactiveCollection <ReactivePropertySlim <Type> >();
rc.AddRangeOnScheduler(XamlCreator.GetControlList().Select(x => new ReactivePropertySlim <Type>(x)));
bool FilterFunc(ReactivePropertySlim <Type> x)
{
return(string.IsNullOrWhiteSpace(this.SearchWord.Value) || x.Value.ToString().IndexOf(this.SearchWord.Value, StringComparison.OrdinalIgnoreCase) >= 0);
}
this.Controls = rc.ToFilteredReadOnlyObservableCollection(FilterFunc);
this.SearchWord.Subscribe(_ => {
this.Controls.Refresh(FilterFunc);
});
this.Xaml = this.SelectedControl.Select(x => XamlCreator.Create(x?.Value)).ToReadOnlyReactivePropertySlim();
}
public MainWindowViewModel()
{
#region Test
AddMemberName = new ReactiveProperty <string>(string.Empty);
AddMemberIsLong = new ReactiveProperty <bool>(false);
AddMemberIsSelected = new ReactiveProperty <bool>(false);
RemoveMemberName = new ReactiveProperty <string>(string.Empty);
AddMemberCommand = new AsyncReactiveCommand();
AddMemberCommand.Subscribe(_ => AddMember(AddMemberName.Value, AddMemberIsLong.Value, AddMemberIsSelected.Value));
RemoveMemberCommand = new ReactiveCommand();
RemoveMemberCommand.Subscribe(_ => RemoveMember(RemoveMemberName.Value));
ClearMemberCommand = Members.ObserveProperty(x => x.Count).Select(x => 0 < x).ToReactiveCommand();
ClearMemberCommand.Subscribe(_ => ClearMember());
#endregion
PopulateMembers();
Members
.ObserveElementProperty(x => x.IsLong)
.Where(x => x.Value)
.Subscribe(x => ShowName(x.Instance));
Members
.ObserveElementObservableProperty(x => x.IsSelected)
.Where(x => x.Value)
.Subscribe(x => ShowName(x.Instance));
// IsAllLong: Original
IsAllLong = Members
.ObserveElementProperty(x => x.IsLong)
.Select(_ => Members.All(x => x.IsLong))
.ToReactiveProperty();
// IsAllLong: Alternative
IFilteredReadOnlyObservableCollection <MemberViewModel> membersNotLong = Members
.ToFilteredReadOnlyObservableCollection(x => !x.IsLong);
IsAllLong = membersNotLong
.CollectionChangedAsObservable()
.Select(_ => Members.Any() && (0 == membersNotLong.Count))
.ToReactiveProperty();
// IsAnySelected: Original
IsAnySelected = Members
.ObserveElementObservableProperty(x => x.IsSelected)
.Select(_ => Members.Any(x => x.IsSelected.Value))
.ToReactiveProperty();
// IsAnySelected: Alternative 1
List <MemberViewModel> membersSelected = new List <MemberViewModel>();
IObservable <bool> elementPropertyChanged = Members
.ObserveElementObservableProperty(x => x.IsSelected)
.Do(x =>
{
if (!x.Value)
{
membersSelected.Remove(x.Instance);
}
else if (!membersSelected.Contains(x.Instance))
{
membersSelected.Add(x.Instance);
}
})
.Select(_ => 0 < membersSelected.Count);
IObservable <bool> collectionChanged = Members
.CollectionChangedAsObservable()
.Where(x => x.Action != NotifyCollectionChangedAction.Move)
.Do(x =>
{
switch (x.Action)
{
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Replace:
if (x.OldItems != null)
{
foreach (var instance in x.OldItems.Cast <MemberViewModel>())
{
membersSelected.Remove(instance);
}
}
if (x.NewItems != null)
{
foreach (var instance in x.NewItems.Cast <MemberViewModel>())
{
if (membersSelected.Contains(instance))
{
continue;
}
if (instance.IsSelected.Value)
{
membersSelected.Add(instance);
}
}
}
break;
case NotifyCollectionChangedAction.Reset:
membersSelected.Clear();
break;
}
})
.Select(_ => 0 < membersSelected.Count);
IsAnySelected = Observable.Merge(elementPropertyChanged, collectionChanged)
.ToReactiveProperty();
// IsAnySelected: Alternative 2
IsAnySelected = Members
.ObserveElementBooleanObservableProperty(x => x.IsSelected)
.Select(x => 0 < x.Count)
.ToReactiveProperty();
// IsAnySelected: Alternative 3
IsAnySelected = Members
.ObserveElementFilteredObservableProperty(x => x.IsSelected, x => x)
.Select(x => 0 < x.Count)
.ToReactiveProperty();
}
/// <summary>
/// Observe collection element's PropertyChanged event.
/// </summary>
/// <typeparam name="TElement">Type of Element</typeparam>
/// <param name="source">source collection</param>
/// <returns>PropertyChanged event stream.</returns>
public static IObservable <SenderEventArgsPair <TElement, PropertyChangedEventArgs> > ObserveElementPropertyChanged <TElement>(this IFilteredReadOnlyObservableCollection <TElement> source)
where TElement : class, INotifyPropertyChanged =>
CollectionUtilities.ObserveElementPropertyChanged <IFilteredReadOnlyObservableCollection <TElement>, TElement>(source);
/// <summary>
/// Observe collection element's IObservable sequence.
/// </summary>
/// <typeparam name="TElement">Collection element type</typeparam>
/// <typeparam name="TProperty">Type of observable property element</typeparam>
/// <param name="source">Source collection</param>
/// <param name="propertySelector">IObservable selection expression</param>
/// <returns>IObservable sequence sequence</returns>
public static IObservable <PropertyPack <TElement, TProperty> > ObserveElementObservableProperty <TElement, TProperty>(this IFilteredReadOnlyObservableCollection <TElement> source, Expression <Func <TElement, IObservable <TProperty> > > propertySelector)
where TElement : class, INotifyPropertyChanged =>
CollectionUtilities.ObserveElementObservableProperty(source, propertySelector);
/// <summary>
/// Observe collection element's property.
/// </summary>
/// <typeparam name="TElement">Type of element</typeparam>
/// <typeparam name="TProperty">Type of property</typeparam>
/// <param name="source">Data source</param>
/// <param name="propertySelector">Property selection expression</param>
/// <param name="isPushCurrentValueAtFirst">Push current value on first subscribe</param>
/// <returns>Property sequence</returns>
public static IObservable <PropertyPack <TElement, TProperty> > ObserveElementProperty <TElement, TProperty>(this IFilteredReadOnlyObservableCollection <TElement> source, Expression <Func <TElement, TProperty> > propertySelector, bool isPushCurrentValueAtFirst = true)
where TElement : class, INotifyPropertyChanged =>
CollectionUtilities.ObserveElementProperty(source, propertySelector, isPushCurrentValueAtFirst);
