/// <summary> /// Initializes a new instance of the <see cref="GroupingReadOnlyObservableListSource{TSource, TKey}" /> class. /// </summary> /// <param name="source">The source sequence.</param> /// <param name="keySelector">The function used to obtain keys that represent the items.</param> /// <param name="keyComparer"> /// The comparer used for key comparison. Specify <c>null</c> to use the default comparer for /// <typeparamref name="TKey" />. /// </param> /// <param name="sourceComparer"> /// A comparer for the source items. This is only used if the source collection is not a list /// and does not provide index information in its <see cref="NotifyCollectionChangedEventArgs" /> events. /// </param> public GroupingReadOnlyObservableListSource(IEnumerable <TSource> source, Expression <Func <TSource, TKey> > keySelector, IEqualityComparer <TKey> keyComparer, IEqualityComparer <TSource> sourceComparer) : this( source, item => PropertyObservableFactory <TSource, TKey> .CreateFrom(keySelector).Observe(item), keyComparer, sourceComparer, new ObservableCollection <ReadOnlyObservableGroup <TSource, TKey> >()) { }
/// <summary> /// Initializes a new instance of the <see cref="InnerJoinReadOnlyObservableCollection{TOuter, TInner, TKey, TResult}"/> class. /// </summary> /// <param name="outerSource">The outer source.</param> /// <param name="innerSource">The inner source.</param> /// <param name="outerKeySelector">The outer key selector.</param> /// <param name="innerKeySelector">The inner key selector.</param> /// <param name="resultSelector">The result selector.</param> /// <param name="keyComparer">The key comparer.</param> /// <param name="outerComparer">The comparer of outer items.</param> /// <param name="innerComparer">The comparer of inner items.</param> /// <exception cref="ArgumentNullException"> /// outerSource /// or /// innerSource /// or /// outerKeySelector /// or /// innerKeySelector /// or /// resultSelector /// </exception> public InnerJoinReadOnlyObservableCollection( IEnumerable <TOuter> outerSource, IEnumerable <TInner> innerSource, Expression <Func <TOuter, TKey> > outerKeySelector, Expression <Func <TInner, TKey> > innerKeySelector, Expression <Func <TOuter, TInner, TResult> > resultSelector, IEqualityComparer <TKey> keyComparer = null, IEqualityComparer <TOuter> outerComparer = null, IEqualityComparer <TInner> innerComparer = null) : this(outerSource, innerSource, PropertyObservableFactory <TOuter, TKey> .CreateFrom(outerKeySelector), PropertyObservableFactory <TInner, TKey> .CreateFrom(innerKeySelector), PropertyObservableFactory <TOuter, TInner, TResult> .CreateFrom(resultSelector), keyComparer, outerComparer, innerComparer) { }
/// <summary> /// Initializes a new instance of the <see cref="SortedReadOnlyObservableList{TSource}"/> class. /// </summary> /// <param name="source">The source collection.</param> /// <param name="keySelector">The key generator.</param> /// <param name="comparer">The comparison used to establish the order of elements (and keys).</param> public KeySortedReadOnlyObservableList(IEnumerable <TSource> source, Expression <Func <TSource, TKey> > keySelector, IComparer <TKey> comparer) : this(source, item => PropertyObservableFactory <TSource, TKey> .CreateFrom(keySelector).Observe(item), comparer == null ? null as Comparison <TKey> : comparer.Compare, null) { }
/// <summary> /// Finds the properties that can affect the result of the specified function. /// </summary> /// <typeparam name="TFirst">The type of the first input.</typeparam> /// <typeparam name="TSecond">The type of the second input.</typeparam> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="function">The function.</param> /// <returns> /// A <see cref="PropertyObservableFactory{TItem, TSecond, TResult}"/> that can be used to /// create <see cref="IObservable{TResult}"/> efficiently. /// </returns> public static PropertyObservableFactory <TFirst, TSecond, TResult> FindProperties <TFirst, TSecond, TResult>( this Expression <Func <TFirst, TSecond, TResult> > function) { return(PropertyObservableFactory <TFirst, TSecond, TResult> .CreateFrom(function)); }
/// <summary> /// Finds the properties that can affect the result of the specified function. /// </summary> /// <typeparam name="TItem">The type of the item.</typeparam> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="function">The function.</param> /// <returns> /// A <see cref="PropertyObservableFactory{TItem, TResult}"/> that can be used to /// create <see cref="IObservable{TResult}"/> efficiently. /// </returns> public static PropertyObservableFactory <TItem, TResult> FindProperties <TItem, TResult>( this Expression <Func <TItem, TResult> > function) where TItem : INotifyPropertyChanged { return(PropertyObservableFactory <TItem, TResult> .CreateFrom(function)); }
/// <summary> /// Creates an <see cref="System.IObservable{T}"/> of a value that can be calculated based on the instance's properties. /// </summary> /// <typeparam name="TItem">The type of the instance.</typeparam> /// <typeparam name="TResult">The type of the observed value.</typeparam> /// <param name="item">The instance.</param> /// <param name="expression">The expression that calculates the value.</param> /// <returns>The observable</returns> /// <remarks> /// The properties that can affect the observable value will be automatically obtained from /// <paramref name="expression"/> using reflection. This may result in observing unnecessary /// read-only properties, as the <see cref="INotifyPropertyChanged"/> does not allow to know /// in advance which properties can generate change notifications. /// </remarks> public static IObservable <TResult> Observe <TItem, TResult>(this TItem item, System.Linq.Expressions.Expression <Func <TItem, TResult> > expression) where TItem : INotifyPropertyChanged { return(PropertyObservableFactory <TItem, TResult> .CreateFrom(expression).Observe(item)); }
public Definition(Expression <Func <TElement, TKey> > keySelector, IComparer <TKey> comparer = null) : this(item => PropertyObservableFactory <TElement, TKey> .CreateFrom(keySelector).Observe(item), comparer) { }
/// <summary> /// Initializes a new instance of the <see cref="PrefixReadOnlyObservableList{T}"/> class. /// </summary> /// <param name="source">The source list.</param> /// <param name="selector">The condition.</param> /// <param name="comparer">The comparer of source items.</param> /// <param name="onRemove">The function that is called when removing an item.</param> /// <param name="onChange">The function that is called when the result assigned to a pair changes.</param> public PrefixReadOnlyObservableList(IReadOnlyList <T> source, Expression <Func <T, bool> > selector, IEqualityComparer <T> comparer = null, Action <bool> onRemove = null, Action <bool, bool> onChange = null) : this(source, PropertyObservableFactory <T, bool> .CreateFrom(selector), comparer, onRemove, onChange) { }